gitghost 1.0.0__tar.gz

gitghost-1.0.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: gitghost
+Version: 1.0.0
+Summary: A CLI tool to securely manage private files/folders ignored in public git repositories.
+Author: Decoding Chris
+License-Expression: MIT
+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: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click<9.0,>=8.0
+Requires-Dist: gitpython<4.0,>=3.1
+
+# GitGhost
+
+A simple CLI tool to securely manage private files and folders ignored in your public Git repositories.
+
+---
+
+## Why use GitGhost?
+
+- **Keep sensitive files private:** Manage secrets, configs, or personal files outside your public repo.
+- **Seamless Git integration:** Works alongside your existing Git workflow.
+- **Simple commands:** Easily save, check status, or discard private changes.
+- **Separate private repo:** Keeps your private data secure and versioned.
+- **Cross-platform:** Designed for Linux, works on any system with Python 3.10+.
+
+---
+
+## Requirements
+
+- **Python 3.10 or higher**
+- Compatible with Ubuntu/Linux systems
+- An existing Git repository
+
+---
+
+## Installation
+
+Install GitGhost directly from PyPI:
+
+```bash
+pip install gitghost
+```
+
+---
+
+## Quick Start
+
+Initialize GitGhost in your project:
+
+```bash
+gitghost init
+```
+
+Check status of private files:
+
+```bash
+gitghost status
+```
+
+Save private changes:
+
+```bash
+gitghost save
+```
+
+Discard private changes:
+
+```bash
+gitghost discard
+```
+
+---
+
+## How it works
+
+- Specify private files/folders in `.gitghostinclude` (which should also be in `.gitignore`).
+- GitGhost manages a **separate private repository** for these files.
+- `gitghost save` commits and pushes private changes.
+- `gitghost status` shows private file changes.
+- Keeps private data out of your public repo, but safely versioned.
+
+---
+
+## Links
+
+- **PyPI:** (Coming soon)
+- **Source Code:** [https://github.com/decodingchris/gitghost](https://github.com/decodingchris/gitghost)
+- **Issue Tracker:** [https://github.com/decodingchris/gitghost/issues](https://github.com/decodingchris/gitghost/issues)
+
+---
+
+## License
+
+This project is licensed under the **MIT License**. See the [LICENSE](https://opensource.org/licenses/MIT) file for details.

gitghost-1.0.0/README.md

@@ -0,0 +1,83 @@
+# GitGhost
+
+A simple CLI tool to securely manage private files and folders ignored in your public Git repositories.
+
+---
+
+## Why use GitGhost?
+
+- **Keep sensitive files private:** Manage secrets, configs, or personal files outside your public repo.
+- **Seamless Git integration:** Works alongside your existing Git workflow.
+- **Simple commands:** Easily save, check status, or discard private changes.
+- **Separate private repo:** Keeps your private data secure and versioned.
+- **Cross-platform:** Designed for Linux, works on any system with Python 3.10+.
+
+---
+
+## Requirements
+
+- **Python 3.10 or higher**
+- Compatible with Ubuntu/Linux systems
+- An existing Git repository
+
+---
+
+## Installation
+
+Install GitGhost directly from PyPI:
+
+```bash
+pip install gitghost
+```
+
+---
+
+## Quick Start
+
+Initialize GitGhost in your project:
+
+```bash
+gitghost init
+```
+
+Check status of private files:
+
+```bash
+gitghost status
+```
+
+Save private changes:
+
+```bash
+gitghost save
+```
+
+Discard private changes:
+
+```bash
+gitghost discard
+```
+
+---
+
+## How it works
+
+- Specify private files/folders in `.gitghostinclude` (which should also be in `.gitignore`).
+- GitGhost manages a **separate private repository** for these files.
+- `gitghost save` commits and pushes private changes.
+- `gitghost status` shows private file changes.
+- Keeps private data out of your public repo, but safely versioned.
+
+---
+
+## Links
+
+- **PyPI:** (Coming soon)
+- **Source Code:** [https://github.com/decodingchris/gitghost](https://github.com/decodingchris/gitghost)
+- **Issue Tracker:** [https://github.com/decodingchris/gitghost/issues](https://github.com/decodingchris/gitghost/issues)
+
+---
+
+## License
+
+This project is licensed under the **MIT License**. See the [LICENSE](https://opensource.org/licenses/MIT) file for details.

gitghost-1.0.0/gitghost/__init__.py

@@ -0,0 +1 @@
+# GitGhost package init

gitghost-1.0.0/gitghost/cli.py

@@ -0,0 +1,306 @@
+import os
+import shutil
+import datetime
+import click
+from git import Repo, GitCommandError
+
+GITVAULT_INCLUDE = ".gitghostinclude"
+PRIVATE_REPO_DIR = ".gitghost_private"
+
+def parse_gitghostinclude():
+    """Parse .gitghostinclude and return list of file paths."""
+    if not os.path.exists(GITVAULT_INCLUDE):
+        click.echo(f"Error: {GITVAULT_INCLUDE} not found.")
+        return []
+    with open(GITVAULT_INCLUDE, "r") as f:
+        lines = f.readlines()
+    files = []
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        files.append(line)
+    return files
+
+def ensure_private_repo():
+    """Ensure the private repo exists and return Repo object."""
+    private_repo_path = os.path.join(os.getcwd(), PRIVATE_REPO_DIR)
+    if not os.path.exists(private_repo_path):
+        os.makedirs(private_repo_path, exist_ok=True)
+        repo = Repo.init(private_repo_path)
+    else:
+        try:
+            repo = Repo(private_repo_path)
+        except Exception:
+            repo = Repo.init(private_repo_path)
+    return repo
+
+def copy_private_files(files):
+    """Copy private files into .gitghost_private/ preserving paths."""
+    for file_path in files:
+        src = os.path.join(os.getcwd(), file_path)
+        if not os.path.exists(src):
+            continue
+        dest = os.path.join(os.getcwd(), PRIVATE_REPO_DIR, file_path)
+        if os.path.isdir(src):
+            # Copy directory recursively
+            if os.path.exists(dest):
+                shutil.rmtree(dest)
+            shutil.copytree(src, dest)
+        else:
+            dest_dir = os.path.dirname(dest)
+            os.makedirs(dest_dir, exist_ok=True)
+            shutil.copy2(src, dest)
+
+@click.group()
+def cli():
+    """GitGhost CLI - manage private files securely."""
+    pass
+
+@cli.command()
+def status():
+    """Show status of private files."""
+    files = parse_gitghostinclude()
+    if not files:
+        return
+
+    # Copy private files into private repo dir
+    copy_private_files(files)
+
+    # Open or init private repo
+    repo = ensure_private_repo()
+    
+    # If private repo has no commits, instruct user to run save
+    if not repo.head.is_valid():
+        click.echo("Private repo is empty. The following files/folders will be added on first save:")
+        for f in files:
+            click.echo(f"  {f}")
+        click.echo("Run 'gitghost save' to create the initial commit of your private files.")
+        return
+    
+    changed_files = []
+    import os as _os
+    
+    for file_path in files:
+        vault_path = os.path.join(os.getcwd(), PRIVATE_REPO_DIR, file_path)
+        if not os.path.exists(vault_path):
+            click.echo(f"Missing in vault: {file_path}")
+            continue
+    
+        paths_to_check = []
+        if os.path.isdir(vault_path):
+            # Recursively add all files inside directory
+            for root, dirs, filenames in _os.walk(vault_path):
+                for fname in filenames:
+                    full_path = os.path.join(root, fname)
+                    rel = os.path.relpath(full_path, os.path.join(os.getcwd(), PRIVATE_REPO_DIR))
+                    paths_to_check.append(rel)
+        else:
+            rel = file_path
+            paths_to_check.append(rel)
+    
+        try:
+            diff_index = repo.index.diff(None)
+            for rel_path in paths_to_check:
+                changed = any(d.a_path == rel_path for d in diff_index)
+                untracked = rel_path in repo.untracked_files
+                if changed or untracked:
+                    changed_files.append(rel_path)
+        except GitCommandError:
+            continue
+
+    if changed_files:
+        click.echo("Changed private files:")
+        for f in changed_files:
+            click.echo(f"  {f}")
+    else:
+        click.echo("No changes in private files.")
+
+@cli.command()
+@click.option('--message', '-m', default=None, help='Commit message')
+def save(message):
+    """Save changes of private files to private repo."""
+    if not message:
+        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+        message = f"GitGhost backup on {now}"
+    files = parse_gitghostinclude()
+    if not files:
+        return
+    
+    import subprocess
+    private_repo_path = os.path.join(os.getcwd(), PRIVATE_REPO_DIR)
+    repo = Repo(private_repo_path)
+    if repo.head.is_valid():
+        subprocess.run(["git", "-C", private_repo_path, "reset", "--hard", "HEAD"], check=True)
+    else:
+        click.echo("Private repo is empty, skipping reset.")
+
+    # Copy private files into private repo dir
+    copy_private_files(files)
+
+    # Open or init private repo
+    repo = ensure_private_repo()
+
+    to_add = []
+    for file_path in files:
+        rel_path = file_path
+        abs_path = os.path.join(os.getcwd(), PRIVATE_REPO_DIR, rel_path)
+        if os.path.exists(abs_path):
+            to_add.append(rel_path)
+
+    if not to_add:
+        click.echo("No files to add.")
+        return
+
+    try:
+        repo.index.add(to_add)
+
+        # Always commit if repo has no commits yet
+        if not repo.head.is_valid() or repo.is_dirty(index=True, working_tree=True, untracked_files=True):
+            repo.index.commit(message)
+            origin = repo.remote(name='origin')
+            try:
+                origin.push()
+            except GitCommandError as e:
+                if "has no upstream branch" in str(e):
+                    repo.git.push('--set-upstream', 'origin', repo.active_branch.name)
+                else:
+                    raise
+            click.echo("Changes saved and pushed.")
+        else:
+            click.echo("No changes to commit.")
+    except GitCommandError as e:
+        click.echo(f"Git error: {e}")
+@cli.command()
+def discard():
+    """Restore private files/folders from the last private repo commit, discarding local changes."""
+    import shutil
+
+    confirm = input("This will OVERWRITE your private files/folders with the last saved private vault snapshot. Are you sure? (y/n): ").strip().lower()
+    if confirm not in ("y", "yes"):
+        click.echo("Discard cancelled.")
+        return
+
+    files = parse_gitghostinclude()
+    # Reset private repo working directory to last commit
+    import subprocess
+    subprocess.run(["git", "-C", os.path.join(os.getcwd(), PRIVATE_REPO_DIR), "reset", "--hard", "HEAD"], check=True)
+    for file_path in files:
+        src = os.path.join(os.getcwd(), PRIVATE_REPO_DIR, file_path)
+        dest = os.path.join(os.getcwd(), file_path)
+
+        if not os.path.exists(src):
+            click.echo(f"Skipping missing in vault: {file_path}")
+            continue
+
+        if os.path.isdir(src):
+            if os.path.exists(dest):
+                shutil.rmtree(dest)
+            shutil.copytree(src, dest)
+            click.echo(f"Restored directory: {file_path}")
+        else:
+            dest_dir = os.path.dirname(dest)
+            os.makedirs(dest_dir, exist_ok=True)
+            shutil.copy2(src, dest)
+            click.echo(f"Restored file: {file_path}")
+
+    click.echo("Private files/folders restored from private vault.")
+
+
+@cli.command()
+def init():
+    """Initialize GitGhost: create .gitghostinclude, .gitghost_private repo, and update .gitignore."""
+    # Create .gitghostinclude if missing
+    if not os.path.exists(GITVAULT_INCLUDE):
+        with open(GITVAULT_INCLUDE, "w") as f:
+            f.write("# List private files and folders, one per line\n")
+        click.echo(f"Created {GITVAULT_INCLUDE}")
+    else:
+        click.echo(f"{GITVAULT_INCLUDE} already exists.")
+
+    # Create .gitghost_private directory and init repo
+    private_repo_path = os.path.join(os.getcwd(), PRIVATE_REPO_DIR)
+    if not os.path.exists(private_repo_path):
+        os.makedirs(private_repo_path, exist_ok=True)
+        Repo.init(private_repo_path)
+        click.echo(f"Initialized private repo in {PRIVATE_REPO_DIR}")
+    else:
+        try:
+            Repo(private_repo_path)
+            click.echo(f"Private repo already exists in {PRIVATE_REPO_DIR}")
+        except Exception:
+            Repo.init(private_repo_path)
+            click.echo(f"Initialized private repo in {PRIVATE_REPO_DIR}")
+
+    # Add .gitghost_private/ to .gitignore if not present
+    # Attempt to create private GitHub repo automatically if gh CLI is available
+    import subprocess
+
+    def has_gh():
+        try:
+            subprocess.run(["gh", "--version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+            return True
+        except Exception:
+            return False
+
+    def get_public_repo_name():
+        try:
+            repo = Repo(os.getcwd())
+            url = next(repo.remote().urls)
+            name = url.split("/")[-1]
+            if name.endswith(".git"):
+                name = name[:-4]
+            return name
+        except Exception:
+            # fallback to current directory name
+            return os.path.basename(os.getcwd())
+
+    private_repo_url = None
+    if has_gh():
+        repo_name = get_public_repo_name() + "-gitghost"
+        try:
+            # Check if repo already exists
+            result = subprocess.run(["gh", "repo", "view", repo_name, "--json", "name"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            if result.returncode != 0:
+                # Repo does not exist, create it
+                subprocess.run(["gh", "repo", "create", repo_name, "--private", "-y"], check=True)
+            else:
+                click.echo(f"Private GitHub repo '{repo_name}' already exists.")
+            username = subprocess.check_output(["gh", "api", "user"], text=True)
+            import json as js
+            username = js.loads(username)["login"]
+            private_repo_url = f"https://github.com/{username}/{repo_name}.git"
+            repo = Repo(private_repo_path)
+            if "origin" not in [r.name for r in repo.remotes]:
+                repo.create_remote("origin", private_repo_url)
+                click.echo(f"Created and added remote: {private_repo_url}")
+        except Exception:
+            click.echo("Failed to create private GitHub repo automatically. You can create it manually and add as remote.")
+    else:
+        click.echo("GitHub CLI (gh) not found. Skipping automatic private repo creation.")
+    gitignore_path = os.path.join(os.getcwd(), ".gitignore")
+    vault_block = "# GitGhost\n.gitghost_private/\n.gitghostinclude\n"
+    
+    def block_present(content):
+        return ".gitghost_private/" in content and ".gitghostinclude" in content
+    
+    if os.path.exists(gitignore_path):
+        with open(gitignore_path, "r") as f:
+            content = f.read()
+        if not block_present(content):
+            content = content.rstrip()
+            if content != "":
+                content += "\n\n"  # ensure one blank line before block
+            content += vault_block
+            with open(gitignore_path, "w") as f:
+                f.write(content)
+            click.echo("Added GitGhost block to .gitignore")
+        else:
+            click.echo("GitGhost block already present in .gitignore")
+    else:
+        with open(gitignore_path, "w") as f:
+            f.write(vault_block)
+        click.echo("Created .gitignore with GitGhost block")
+
+if __name__ == "__main__":
+    cli()

gitghost-1.0.0/gitghost.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: gitghost
+Version: 1.0.0
+Summary: A CLI tool to securely manage private files/folders ignored in public git repositories.
+Author: Decoding Chris
+License-Expression: MIT
+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: Operating System :: POSIX :: Linux
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click<9.0,>=8.0
+Requires-Dist: gitpython<4.0,>=3.1
+
+# GitGhost
+
+A simple CLI tool to securely manage private files and folders ignored in your public Git repositories.
+
+---
+
+## Why use GitGhost?
+
+- **Keep sensitive files private:** Manage secrets, configs, or personal files outside your public repo.
+- **Seamless Git integration:** Works alongside your existing Git workflow.
+- **Simple commands:** Easily save, check status, or discard private changes.
+- **Separate private repo:** Keeps your private data secure and versioned.
+- **Cross-platform:** Designed for Linux, works on any system with Python 3.10+.
+
+---
+
+## Requirements
+
+- **Python 3.10 or higher**
+- Compatible with Ubuntu/Linux systems
+- An existing Git repository
+
+---
+
+## Installation
+
+Install GitGhost directly from PyPI:
+
+```bash
+pip install gitghost
+```
+
+---
+
+## Quick Start
+
+Initialize GitGhost in your project:
+
+```bash
+gitghost init
+```
+
+Check status of private files:
+
+```bash
+gitghost status
+```
+
+Save private changes:
+
+```bash
+gitghost save
+```
+
+Discard private changes:
+
+```bash
+gitghost discard
+```
+
+---
+
+## How it works
+
+- Specify private files/folders in `.gitghostinclude` (which should also be in `.gitignore`).
+- GitGhost manages a **separate private repository** for these files.
+- `gitghost save` commits and pushes private changes.
+- `gitghost status` shows private file changes.
+- Keeps private data out of your public repo, but safely versioned.
+
+---
+
+## Links
+
+- **PyPI:** (Coming soon)
+- **Source Code:** [https://github.com/decodingchris/gitghost](https://github.com/decodingchris/gitghost)
+- **Issue Tracker:** [https://github.com/decodingchris/gitghost/issues](https://github.com/decodingchris/gitghost/issues)
+
+---
+
+## License
+
+This project is licensed under the **MIT License**. See the [LICENSE](https://opensource.org/licenses/MIT) file for details.

gitghost-1.0.0/gitghost.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+gitghost/__init__.py
+gitghost/cli.py
+gitghost.egg-info/PKG-INFO
+gitghost.egg-info/SOURCES.txt
+gitghost.egg-info/dependency_links.txt
+gitghost.egg-info/entry_points.txt
+gitghost.egg-info/requires.txt
+gitghost.egg-info/top_level.txt
+tests/test_integration.py
+tests/test_unit.py

gitghost-1.0.0/gitghost.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gitghost-1.0.0/gitghost.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gitghost = gitghost.cli:cli

gitghost-1.0.0/gitghost.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click<9.0,>=8.0
+gitpython<4.0,>=3.1

gitghost-1.0.0/gitghost.egg-info/top_level.txt

@@ -0,0 +1 @@
+gitghost

gitghost-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gitghost"
+version = "1.0.0"
+description = "A CLI tool to securely manage private files/folders ignored in public git repositories."
+authors = [
+    { name = "Decoding Chris" }
+]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.0,<9.0",
+    "gitpython>=3.1,<4.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: POSIX :: Linux",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Version Control"
+]
+
+[project.scripts]
+gitghost = "gitghost.cli:cli"

gitghost-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gitghost-1.0.0/tests/test_integration.py

@@ -0,0 +1,284 @@
+import pytest
+from click.testing import CliRunner
+from gitghost.cli import cli
+from unittest import mock
+from git import GitCommandError
+import os
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+def test_init_creates_include_and_repo(tmp_path, runner):
+    os.chdir(tmp_path)
+    result = runner.invoke(cli, ["init"])
+    assert result.exit_code == 0
+    assert ".gitghostinclude" in os.listdir()
+    assert ".gitghost_private" in os.listdir()
+    assert "Initialized private repo" in result.output or "already exists" in result.output
+
+def test_init_when_include_exists(tmp_path, runner):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("# test\n")
+    result = runner.invoke(cli, ["init"])
+    assert result.exit_code == 0
+    assert ".gitghostinclude" in os.listdir()
+    assert "already exists" in result.output
+
+def test_save_no_files(tmp_path, runner):
+    os.chdir(tmp_path)
+    # No .gitghostinclude file
+    result = runner.invoke(cli, ["save"])
+    assert result.exit_code == 0 or result.exit_code == 1
+    # Should handle missing include gracefully
+
+def test_save_with_message(tmp_path, runner):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    # Initialize repo first
+    runner.invoke(cli, ["init"])
+    result = runner.invoke(cli, ["save", "--message", "my commit"])
+    assert result.exit_code in (0, 1)
+
+def test_status_empty_include(tmp_path, runner):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("")
+    runner.invoke(cli, ["init"])
+    result = runner.invoke(cli, ["status"])
+    assert result.exit_code in (0, 1)
+
+def test_status_missing_include(tmp_path, runner):
+    os.chdir(tmp_path)
+    result = runner.invoke(cli, ["status"])
+    assert result.exit_code in (0, 1)
+    assert "not found" in result.output or "No changes" in result.output
+
+def test_discard_cancel(tmp_path, runner):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    runner.invoke(cli, ["init"])
+    # Simulate user entering 'n' to cancel discard
+    result = runner.invoke(cli, ["discard"], input="n\n")
+    assert result.exit_code in (0, 1)
+    assert "cancelled" in result.output or "Discard cancelled" in result.output
+
+def test_discard_confirm(tmp_path, runner):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    runner.invoke(cli, ["init"])
+    # Simulate user entering 'y' to confirm discard
+    result = runner.invoke(cli, ["discard"], input="y\n")
+    assert result.exit_code in (0, 1)
+    # Should attempt to restore files or print restored message
+
+def test_status_empty_private_repo(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = False
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["status"])
+        assert "Private repo is empty" in result.output
+
+def test_status_missing_files(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.return_value = []
+    repo_mock.untracked_files = []
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=False):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["status"])
+        assert "Missing in vault" in result.output
+
+def test_status_directory_recursion(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.return_value = []
+    repo_mock.untracked_files = []
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["dir1"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=True), \
+         mock.patch("os.path.isdir", return_value=True), \
+         mock.patch("os.walk", return_value=[("/vault/dir1", [], ["a.txt", "b.txt"])]):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["status"])
+        # Should not crash, may or may not print files
+
+def test_status_git_command_error(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.side_effect = GitCommandError("diff", 1)
+    repo_mock.untracked_files = []
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=True):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["status"])
+        # Should handle error gracefully, no crash
+
+def test_status_no_changes(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.return_value = []
+    repo_mock.untracked_files = []
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=True):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["status"])
+        # Should not print "Changed private files"
+def test_init_github_cli_not_installed(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        assert "GitHub CLI (gh) not found" in result.output
+
+def test_init_github_repo_creation_failure(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    def subprocess_run_side_effect(*args, **kwargs):
+        if "gh" in args[0]:
+            raise Exception("gh error")
+        return mock.DEFAULT
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=subprocess_run_side_effect):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        assert "Failed to create private GitHub repo automatically" in result.output or "GitHub CLI (gh) not found" in result.output
+
+def test_init_gitignore_missing(monkeypatch, tmp_path):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        assert ".gitignore" in os.listdir()
+
+def test_init_gitignore_exists_without_block(monkeypatch, tmp_path):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    (tmp_path / ".gitignore").write_text("node_modules/\n")
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        content = (tmp_path / ".gitignore").read_text()
+        assert ".gitghost_private" in content
+
+def test_init_gitignore_exists_with_block(monkeypatch, tmp_path):
+    os.chdir(tmp_path)
+    (tmp_path / ".gitghostinclude").write_text("secret.txt\n")
+    (tmp_path / "secret.txt").write_text("top secret")
+    (tmp_path / ".gitignore").write_text("# GitGhost\n.gitghost_private/\n.gitghostinclude\n")
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        content = (tmp_path / ".gitignore").read_text()
+        assert content.count(".gitghost_private") == 1  # no duplicate block
+
+def test_init_private_repo_fallback(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: True)
+    repo_cls = mock.Mock(side_effect=Exception("fail"))
+    repo_init = mock.Mock()
+    with mock.patch("gitghost.cli.Repo", repo_cls), \
+         mock.patch("gitghost.cli.Repo.init", repo_init), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        repo_init.assert_called()
+def test_status_git_command_error_branches(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.side_effect = GitCommandError("diff", 1)
+    repo_mock.untracked_files = []
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=True):
+        runner = CliRunner()
+def test_init_nested_exceptions(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    repo_cls = mock.Mock(side_effect=Exception("fail"))
+    repo_init = mock.Mock()
+    def subprocess_run_side_effect(*args, **kwargs):
+        if "gh" in args[0]:
+            return mock.Mock(returncode=0)
+        return mock.DEFAULT
+    with mock.patch("gitghost.cli.Repo", repo_cls), \
+         mock.patch("gitghost.cli.Repo.init", repo_init), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=subprocess_run_side_effect), \
+         mock.patch("subprocess.check_output", side_effect=Exception("fail")), \
+         mock.patch("gitghost.cli.Repo.create_remote", side_effect=Exception("fail")):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        # Should handle nested exceptions gracefully
+        result = runner.invoke(cli, ["status"])
+        # Should handle error gracefully, no crash
+def test_init_repo_exists_exception(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: True)
+    repo_cls = mock.Mock(side_effect=Exception("fail"))
+    repo_init = mock.Mock()
+    with mock.patch("gitghost.cli.Repo", repo_cls), \
+         mock.patch("gitghost.cli.Repo.init", repo_init), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        repo_init.assert_called()
+
+def test_init_get_public_repo_name_exception(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run") as subproc_mock, \
+         mock.patch("gitghost.cli.Repo") as repo_mock:
+        repo_mock.return_value.remote.return_value.urls = ["https://github.com/user/repo.git"]
+        repo_mock.side_effect = Exception("fail")
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        # Should fallback to directory name, no crash
+
+def test_init_subprocess_repo_create_failure(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    def subprocess_run_side_effect(*args, **kwargs):
+        if "gh" in args[0]:
+            raise Exception("gh error")
+        return mock.DEFAULT
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=subprocess_run_side_effect):
+        runner = CliRunner()
+        result = runner.invoke(cli, ["init"])
+        # Should handle error gracefully
+
+def test_cli_entry_point():
+    # Cover line 300
+    from gitghost import cli as cli_module
+    with pytest.raises(SystemExit):
+        cli_module.cli()

gitghost-1.0.0/tests/test_unit.py

@@ -0,0 +1,273 @@
+import os
+import pytest
+from unittest import mock
+from click.testing import CliRunner
+from gitghost import cli
+
+def test_parse_gitghostinclude_missing(monkeypatch):
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    with mock.patch("builtins.print"):
+        files = cli.parse_gitghostinclude()
+    assert files == []
+
+def test_ensure_private_repo_init_when_missing(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    with mock.patch("os.makedirs") as makedirs_mock, \
+         mock.patch("gitghost.cli.Repo.init") as repo_init_mock:
+        repo_obj = mock.Mock()
+        repo_init_mock.return_value = repo_obj
+        repo = cli.ensure_private_repo()
+        makedirs_mock.assert_called()
+        repo_init_mock.assert_called()
+        assert repo == repo_obj
+
+def test_ensure_private_repo_fallback_to_init(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: True)
+    with mock.patch("gitghost.cli.Repo") as repo_cls, \
+         mock.patch("gitghost.cli.Repo.init") as repo_init_mock:
+        repo_cls.side_effect = Exception("fail")
+        repo_obj = mock.Mock()
+        repo_init_mock.return_value = repo_obj
+        repo = cli.ensure_private_repo()
+        repo_init_mock.assert_called()
+        assert repo == repo_obj
+
+def test_copy_private_files_skips_missing(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    cli.copy_private_files(["secret.txt"])  # Should skip without error
+
+def test_copy_private_files_directory(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    # Source exists and is directory
+    def exists_side_effect(path):
+        if "secret_dir" in path:
+            return True
+        return False
+    monkeypatch.setattr("os.path.exists", exists_side_effect)
+    monkeypatch.setattr("os.path.isdir", lambda p: True)
+    with mock.patch("shutil.rmtree") as rmtree_mock, \
+         mock.patch("shutil.copytree") as copytree_mock:
+        cli.copy_private_files(["secret_dir"])
+        rmtree_mock.assert_called()
+        copytree_mock.assert_called()
+
+def test_save_push_error(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = False
+    repo_mock.index.diff.return_value = []
+    repo_mock.untracked_files = []
+    repo_mock.index.add.return_value = None
+    repo_mock.is_dirty.return_value = True
+    repo_mock.remote.return_value.push.side_effect = cli.GitCommandError("push", 1)
+    repo_mock.remote.return_value.git.push.side_effect = None
+    repo_mock.remote.return_value.name = "origin"
+    repo_mock.remotes = []
+    repo_mock.active_branch.name = "main"
+
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["secret.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("subprocess.run"), \
+         mock.patch("os.path.exists", return_value=True), \
+         mock.patch("os.getcwd", return_value="/tmp/testcwd"):
+        runner = CliRunner()
+        result = runner.invoke(cli.save, ["--message", "test commit"])
+        # Accept any exit code, just ensure no crash
+        assert result.exit_code in (0, 1)
+
+def test_init_github_cli_missing(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=FileNotFoundError):
+        runner = CliRunner()
+        result = runner.invoke(cli.init)
+        assert result.exit_code in (0, 1)
+
+def test_parse_gitghostinclude_with_comments_and_empty(monkeypatch):
+    monkeypatch.setattr("os.path.exists", lambda p: True)
+    mock_file = mock.mock_open(read_data="# comment line\n\nfile1.txt\n  \n#another\nfile2.txt\n")
+    with mock.patch("builtins.open", mock_file):
+        files = cli.parse_gitghostinclude()
+    assert files == ["file1.txt", "file2.txt"]
+
+def test_status_git_error(monkeypatch):
+    repo_mock = mock.Mock()
+    repo_mock.head.is_valid.return_value = True
+    repo_mock.index.diff.side_effect = cli.GitCommandError("diff", 1)
+    
+    with mock.patch("gitghost.cli.ensure_private_repo", return_value=repo_mock), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["secret.txt"]), \
+         mock.patch("gitghost.cli.copy_private_files"), \
+         mock.patch("os.path.exists", return_value=True), \
+         mock.patch("os.path.isdir", return_value=False):
+        runner = CliRunner()
+        result = runner.invoke(cli.status)
+        assert result.exit_code == 0  # Should handle error gracefully
+
+def test_init_repo_name_fallback(monkeypatch):
+    """Test init command falls back to directory name when git repo check fails"""
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    monkeypatch.setattr("os.path.basename", lambda p: "fallback-name")
+    
+    # Mock subprocess.run to simulate gh command available
+    def run_side_effect(*args, **kwargs):
+        if args[0][0] == "gh" and args[0][1] == "--version":
+            return mock.Mock(returncode=0)
+        elif args[0][0] == "gh" and args[0][1] == "repo":
+            return mock.Mock(returncode=1)  # Repo doesn't exist
+        return mock.Mock(returncode=0)
+
+    with mock.patch("gitghost.cli.Repo", side_effect=Exception("repo error")), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=run_side_effect) as subprocess_run:
+        runner = CliRunner()
+        result = runner.invoke(cli.init)
+        assert result.exit_code == 0
+        # Check if gh create was called with fallback name
+        create_calls = [c for c in subprocess_run.call_args_list if c[0][0][1] == "repo" and c[0][0][2] == "create"]
+        assert any("fallback-name-gitghost" in str(call) for call in create_calls)
+
+def test_init_gitignore_updating(monkeypatch):
+    """Test .gitignore updating with various content states"""
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    test_cases = [
+        # Case 1: No GitGhost entries
+        "some content\n",
+        # Case 2: Has .gitghost_private/ but not .gitghostinclude
+        "some content\n.gitghost_private/\n",
+        # Case 3: Has .gitghostinclude but not .gitghost_private/
+        "some content\n.gitghostinclude\n",
+        # Case 4: Already has both entries
+        "some content\n.gitghost_private/\n.gitghostinclude\n"
+    ]
+    
+    for content in test_cases:
+        with mock.patch("gitghost.cli.open", mock.mock_open(read_data=content), create=True) as mock_file, \
+             mock.patch("os.path.exists", return_value=True), \
+             mock.patch("gitghost.cli.Repo.init"):
+            runner = CliRunner()
+            result = runner.invoke(cli.init)
+            assert result.exit_code == 0
+            
+            # Check write calls when content needed updating
+            if ".gitghost_private/" not in content or ".gitghostinclude" not in content:
+                mock_file().write.assert_called()
+            else:
+                # Both entries present, no update needed
+                assert not mock_file().write.called or mock_file().write.call_count == 0
+
+def test_init_gh_create_error(monkeypatch):
+    """Test init command when GitHub CLI repo creation fails"""
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)
+    
+    def subprocess_run_mock(*args, **kwargs):
+        if args[0][0] == "gh" and args[0][1] == "--version":
+            return mock.Mock(returncode=0)  # gh CLI is available
+        if args[0][0] == "gh" and args[0][1] == "repo" and args[0][2] == "create":
+            raise Exception("gh create error")
+        return mock.Mock(returncode=1)
+    
+    with mock.patch("gitghost.cli.Repo.init"), \
+         mock.patch("gitghost.cli.open", mock.mock_open(), create=True), \
+         mock.patch("subprocess.run", side_effect=subprocess_run_mock):
+        runner = CliRunner()
+        result = runner.invoke(cli.init)
+        assert result.exit_code == 0
+        assert "Failed to create private GitHub repo" in result.output
+
+def test_copy_private_files_file_copy_error(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    def exists_side_effect(path):
+        if "secret_file.txt" in path:
+            return True
+        return False
+    monkeypatch.setattr("os.path.exists", exists_side_effect)
+    monkeypatch.setattr("os.path.isdir", lambda p: False)
+    with mock.patch("os.path.dirname", return_value="/tmp/testcwd/.gitghost_private"), \
+         mock.patch("os.makedirs"), \
+         mock.patch("shutil.copy2", side_effect=Exception("copy error")):
+        with pytest.raises(Exception):
+            cli.copy_private_files(["secret_file.txt"])
+def test_copy_private_files_file_copy(monkeypatch):
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    # Source exists and is a file
+    def exists_side_effect(path):
+        if "secret_file.txt" in path:
+            return True
+        return False
+    monkeypatch.setattr("os.path.exists", exists_side_effect)
+    monkeypatch.setattr("os.path.isdir", lambda p: False)
+    with mock.patch("os.path.dirname", return_value="/tmp/testcwd/.gitghost_private"), \
+         mock.patch("os.makedirs") as makedirs_mock, \
+         mock.patch("shutil.copy2") as copy2_mock:
+        cli.copy_private_files(["secret_file.txt"])
+        makedirs_mock.assert_called()
+        copy2_mock.assert_called()
+
+def test_discard_cancel(monkeypatch):
+    """Test discard command when user cancels"""
+    with mock.patch("builtins.input", return_value="n"):
+        runner = CliRunner()
+        result = runner.invoke(cli.discard)
+        assert result.exit_code == 0
+        assert "Discard cancelled" in result.output
+
+def test_discard_confirmed_with_missing_files(monkeypatch):
+    """Test discard command with confirmed overwrite and some missing vault files"""
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    monkeypatch.setattr("os.path.exists", lambda p: False)  # Files missing in vault
+    
+    with mock.patch("builtins.input", return_value="y"), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt", "dir1"]), \
+         mock.patch("subprocess.run"):
+        runner = CliRunner()
+        result = runner.invoke(cli.discard)
+        assert result.exit_code == 0
+        assert "Skipping missing in vault: file1.txt" in result.output
+        assert "Skipping missing in vault: dir1" in result.output
+
+def test_discard_confirmed_with_files(monkeypatch):
+    """Test discard command with confirmed overwrite and existing files"""
+    monkeypatch.setattr("os.getcwd", lambda: "/tmp/testcwd")
+    
+    def exists_side_effect(path):
+        # Files in vault that we want to restore
+        vault_paths = [
+            "/tmp/testcwd/.gitghost_private/file1.txt",
+            "/tmp/testcwd/.gitghost_private/dir1"
+        ]
+        # Existing target that needs to be removed
+        target_paths = ["/tmp/testcwd/dir1"]
+        return path in vault_paths + target_paths
+    
+    monkeypatch.setattr("os.path.exists", exists_side_effect)
+    
+    with mock.patch("builtins.input", return_value="yes"), \
+         mock.patch("gitghost.cli.parse_gitghostinclude", return_value=["file1.txt", "dir1"]), \
+         mock.patch("subprocess.run"), \
+         mock.patch("os.path.isdir") as isdir_mock, \
+         mock.patch("os.makedirs") as makedirs_mock, \
+         mock.patch("shutil.copy2") as copy2_mock, \
+         mock.patch("shutil.rmtree") as rmtree_mock, \
+         mock.patch("shutil.copytree") as copytree_mock:
+        
+        def isdir_side_effect(path):
+            return "dir1" in path
+        isdir_mock.side_effect = isdir_side_effect
+        
+        runner = CliRunner()
+        result = runner.invoke(cli.discard)
+        assert result.exit_code == 0
+        
+        # Verify file operations
+        rmtree_mock.assert_called_once_with("/tmp/testcwd/dir1")
+        copytree_mock.assert_called_once()
+        makedirs_mock.assert_called()
+        copy2_mock.assert_called_once()