naissance 2.0.0__py3-none-any.whl

naissance/__init__.py

@@ -0,0 +1,3 @@
+"""naissance — Git repository genesis utility."""
+
+__version__ = "2.0.0"

naissance/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as `python -m naissance`."""
+
+from naissance.cli import parse_args
+from naissance.core import run
+
+run(parse_args())

naissance/cli.py

@@ -0,0 +1,66 @@
+"""
+cli.py — Argument parsing for naissance.
+
+Usage:
+    naissance <repo_name>                 # CWD-relative (default)
+    naissance <absolute_path> --apath     # Absolute path
+    naissance .                           # CWD, folder name = repo name
+    naissance <repo_name> --public        # Override visibility
+"""
+
+import argparse
+
+from naissance import __version__
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    """
+    Parse command-line arguments and return a Namespace.
+
+    Parameters
+    ----------
+    argv : list[str] | None
+        Explicit argument list (for testing).  Defaults to sys.argv[1:].
+    """
+    parser = argparse.ArgumentParser(
+        prog="naissance",
+        description="Git Repository Genesis — create local + remote repos in one shot.",
+    )
+
+    parser.add_argument(
+        "repo_name",
+        help=(
+            'Name (or path) of the repository to create. '
+            'Resolved relative to CWD by default. '
+            'Use "." for current directory. '
+            'Use --apath for absolute paths.'
+        ),
+    )
+
+    parser.add_argument(
+        "--apath",
+        action="store_true",
+        default=False,
+        help="Treat repo_name as an absolute path.",
+    )
+
+    parser.add_argument(
+        "--name",
+        default=None,
+        help="Explicit name for the remote repository (overrides directory name).",
+    )
+
+    parser.add_argument(
+        "--public",
+        action="store_true",
+        default=False,
+        help="Create the remote repository as public (default: private).",
+    )
+
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"naissance {__version__}",
+    )
+
+    return parser.parse_args(argv)

naissance/core.py

@@ -0,0 +1,261 @@
+"""
+core.py — Main orchestrator for naissance.
+
+Executes the full repo-genesis workflow with ZERO interactive prompts.
+All decisions are driven by defaults.yml.
+"""
+
+import enum
+from pathlib import Path
+
+import yaml
+
+from naissance import errors
+from naissance import git_ops
+from naissance import path_resolver
+
+
+# ── Directory state enum ──────────────────────────────────────────────
+
+class DirState(enum.Enum):
+    NOT_EXISTS = "not_exists"
+    EMPTY = "empty"
+    NON_EMPTY = "non_empty"
+    GIT_INITIALIZED = "git_initialized"
+
+
+def _detect_state(path: Path) -> DirState:
+    """Detect the current state of the target directory."""
+    if not path.exists():
+        return DirState.NOT_EXISTS
+
+    if not path.is_dir():
+        errors.fail(f"Path exists but is not a directory: {path}")
+
+    # Check for .git/ first — a git repo is always "non-empty" but
+    # we treat it as its own state.
+    if (path / ".git").is_dir():
+        return DirState.GIT_INITIALIZED
+
+    # Check if directory is truly empty
+    children = list(path.iterdir())
+    if not children:
+        return DirState.EMPTY
+
+    return DirState.NON_EMPTY
+
+
+# ── Defaults loader ──────────────────────────────────────────────────
+
+def _load_defaults() -> dict:
+    """Load defaults.yml from the package directory."""
+    defaults_path = Path(__file__).parent / "defaults" / "defaults.yml"
+
+    if not defaults_path.exists():
+        errors.fail(f"defaults.yml not found at: {defaults_path}")
+
+    try:
+        with open(defaults_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as exc:
+        errors.fail(f"Failed to parse defaults.yml: {exc}")
+
+    return data or {}
+
+
+# ── Scaffold helpers ─────────────────────────────────────────────────
+
+def _create_scaffold(path: Path, defaults: dict) -> list[str]:
+    """
+    Create README.md and .gitignore based on defaults.
+    Returns list of created filenames (for staging).
+    """
+    created: list[str] = []
+
+    if defaults.get("create_readme", True):
+        readme = path / "README.md"
+        if not readme.exists():
+            readme.write_text("", encoding="utf-8")
+            errors.success("README.md")
+            created.append("README.md")
+        else:
+            errors.warn("README.md already exists, skipping")
+
+    if defaults.get("create_gitignore", True):
+        gitignore = path / ".gitignore"
+        if not gitignore.exists():
+            gitignore.write_text("", encoding="utf-8")
+            errors.success(".gitignore")
+            created.append(".gitignore")
+        else:
+            errors.warn(".gitignore already exists, skipping")
+
+    return created
+
+
+# ── State handlers ────────────────────────────────────────────────────
+
+def _handle_not_exists(
+    path: Path,
+    repo_name: str,
+    visibility: str,
+    defaults: dict,
+) -> None:
+    """Directory doesn't exist → create it, clone remote into it."""
+    path.mkdir(parents=True, exist_ok=True)
+    errors.success(f"Directory created: {path}")
+
+    # Create remote and clone into the directory.
+    # gh repo create <name> --clone creates ./<name> in the parent dir,
+    # so we need the parent, and the folder name must match repo_name.
+    git_ops.gh_repo_create_clone(
+        repo_name,
+        visibility=visibility,
+        clone_into=path,
+    )
+
+    # Scaffold files inside the now-cloned repo
+    created = _create_scaffold(path, defaults)
+
+    if created:
+        git_ops.git_add(path, *created)
+        git_ops.git_commit(path, defaults.get("initial_commit_message", "initial commit"))
+        branch = git_ops.git_branch_current(path, defaults.get("default_branch", "main"))
+        git_ops.git_push(path, branch)
+
+
+def _handle_empty(
+    path: Path,
+    repo_name: str,
+    visibility: str,
+    defaults: dict,
+) -> None:
+    """Directory exists but is empty → clone remote into it."""
+    # gh repo create --clone will try to create the subdir, but it
+    # already exists (empty). We init locally instead, then use --source.
+    git_ops.git_init(path)
+
+    # Create remote from the local source
+    created = _create_scaffold(path, defaults)
+    if created:
+        git_ops.git_add(path, *created)
+        git_ops.git_commit(path, defaults.get("initial_commit_message", "initial commit"))
+
+    git_ops.gh_repo_create_source(
+        path,
+        repo_name,
+        visibility=visibility,
+        push=True,
+    )
+
+
+def _handle_non_empty(
+    path: Path,
+    repo_name: str,
+    visibility: str,
+    defaults: dict,
+) -> None:
+    """Directory has files but no .git → init, scaffold, push."""
+    git_ops.git_init(path)
+
+    _create_scaffold(path, defaults)
+
+    # Stage everything
+    git_ops.git_add(path, ".")
+    git_ops.git_commit(path, defaults.get("initial_commit_message", "initial commit"))
+
+    git_ops.gh_repo_create_source(
+        path,
+        repo_name,
+        visibility=visibility,
+        push=True,
+    )
+
+
+def _handle_git_initialized(
+    path: Path,
+    repo_name: str,
+    visibility: str,
+    defaults: dict,
+) -> None:
+    """Directory already has .git → just link remote."""
+    errors.info("Git already initialized")
+
+    if git_ops.git_has_remote(path):
+        errors.fail("Repository already has a remote origin configured")
+
+    git_ops.gh_repo_create_source(
+        path,
+        repo_name,
+        visibility=visibility,
+        push=True,
+    )
+
+
+# ── Handler dispatch ─────────────────────────────────────────────────
+
+_HANDLERS = {
+    DirState.NOT_EXISTS: _handle_not_exists,
+    DirState.EMPTY: _handle_empty,
+    DirState.NON_EMPTY: _handle_non_empty,
+    DirState.GIT_INITIALIZED: _handle_git_initialized,
+}
+
+
+# ── Main entry ────────────────────────────────────────────────────────
+
+def run(args) -> None:
+    """
+    Execute the full repository genesis workflow.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Parsed CLI arguments (repo_name, apath, public).
+    """
+    errors.header()
+    print("  Birthing repository...\n")
+
+    # ── Load configuration ────────────────────────────────────────────
+    defaults = _load_defaults()
+
+    # ── Preflight checks ──────────────────────────────────────────────
+    errors.require_tool("git")
+    errors.success("git found")
+
+    errors.require_tool("gh", friendly="GitHub CLI (gh)")
+    errors.require_gh_auth()
+    errors.success("gh authenticated")
+
+    # ── Resolve path ──────────────────────────────────────────────────
+    resolved_path, repo_name = path_resolver.resolve(
+        args.repo_name,
+        apath=args.apath,
+    )
+
+    # --name overrides the directory-derived repo name
+    if args.name:
+        repo_name = args.name.strip()
+
+    errors.success(f"Path resolved: {resolved_path}")
+
+    # ── Determine visibility ──────────────────────────────────────────
+    if args.public:
+        visibility = "public"
+    else:
+        visibility = defaults.get("visibility", "private")
+
+    # ── Check if remote already exists ────────────────────────────────
+    if git_ops.gh_repo_exists(repo_name):
+        errors.fail(f"Remote repository already exists: {repo_name}")
+
+    # ── Detect directory state ────────────────────────────────────────
+    state = _detect_state(resolved_path)
+    errors.info(f"Directory state: {state.value}")
+
+    # ── Dispatch to the appropriate handler ───────────────────────────
+    handler = _HANDLERS[state]
+    handler(resolved_path, repo_name, visibility, defaults)
+
+    # ── Done ──────────────────────────────────────────────────────────
+    errors.banner(repo_name)

naissance/errors.py

@@ -0,0 +1,94 @@
+"""
+errors.py — Centralized error handler for naissance.
+
+Provides TUI-style output (✓ / ⨯ / ⚠) and prevents raw subprocess
+tracebacks from ever reaching the user's terminal.
+"""
+
+import sys
+
+
+# ── ANSI color codes ──────────────────────────────────────────────────
+_GREEN = "\033[92m"
+_RED = "\033[91m"
+_YELLOW = "\033[93m"
+_CYAN = "\033[96m"
+_DIM = "\033[90m"
+_BOLD = "\033[1m"
+_RESET = "\033[0m"
+
+
+# ── Symbols ───────────────────────────────────────────────────────────
+_CHECK = "✓"
+_CROSS = "⨯"
+_WARN = "⚠"
+_SPARKLE = "✨"
+
+
+def success(msg: str) -> None:
+    """Print a green success line: ✓ msg"""
+    print(f"  {_GREEN}{_CHECK}{_RESET} {msg}")
+
+
+def fail(msg: str, *, exit_code: int = 1) -> None:
+    """Print a red failure line: ⨯ msg — then exit."""
+    print(f"  {_RED}{_CROSS} {msg}{_RESET}", file=sys.stderr)
+    sys.exit(exit_code)
+
+
+def warn(msg: str) -> None:
+    """Print a yellow warning line: ⚠ msg (non-fatal)."""
+    print(f"  {_YELLOW}{_WARN} {msg}{_RESET}")
+
+
+def info(msg: str) -> None:
+    """Print a dim informational line."""
+    print(f"  {_DIM}{msg}{_RESET}")
+
+
+def banner(repo_name: str) -> None:
+    """Print the final celebration line."""
+    print(f"\n  {_SPARKLE} {_CYAN}{_BOLD}{repo_name}{_RESET} is alive.\n")
+
+
+def header() -> None:
+    """Print the naissance header."""
+    print(f"""
+{_DIM}┼─────────────────────────────────────────────────────────────┼
+|       _   __      _
+|      / | / /___ _(_)_____________ _____  ________
+|     /  |/ / __ `/ / ___/ ___/ __ `/ __ \\/ ___/ _ \\
+|    / /|  / /_/ / (__  |__  ) /_/ / / / / /__/  __/
+|   /_/ |_/\\__,_/_/____/____/\\__,_/_/ /_/\\___/\\___/
+|                                        v2.0.0
+|
+|            Git Repository Genesis Utility
+┼─────────────────────────────────────────────────────────────┼{_RESET}
+""")
+
+
+# ── Preflight error helpers ───────────────────────────────────────────
+# Each checks a single condition and calls fail() if it's not met.
+
+def require_tool(tool: str, friendly: str | None = None) -> None:
+    """Verify a CLI tool is available on PATH."""
+    import shutil
+
+    label = friendly or tool
+    if shutil.which(tool) is None:
+        fail(f"{label} is not installed or not on PATH")
+
+
+def require_gh_auth() -> None:
+    """Verify the GitHub CLI is authenticated."""
+    import subprocess
+
+    result = subprocess.run(
+        ["gh", "auth", "status"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if result.returncode != 0:
+        fail("GitHub CLI is not authenticated. Run: gh auth login")

naissance/git_ops.py

@@ -0,0 +1,166 @@
+"""
+git_ops.py — Git and GitHub CLI subprocess wrappers.
+
+Every function routes errors through the centralized ErrorHandler so
+that raw tracebacks never leak into the user's terminal.
+"""
+
+import subprocess
+from pathlib import Path
+
+from naissance import errors
+
+
+def _run(
+    cmd: list[str],
+    *,
+    cwd: Path | None = None,
+    check: bool = True,
+    label: str | None = None,
+) -> subprocess.CompletedProcess[str]:
+    """
+    Run a subprocess, suppressing raw output.
+
+    Parameters
+    ----------
+    cmd : list[str]
+        The command and its arguments.
+    cwd : Path | None
+        Working directory for the command.
+    check : bool
+        If True, call errors.fail() on non-zero exit.
+    label : str | None
+        Human-readable label for error messages (e.g. "git init").
+
+    Returns
+    -------
+    subprocess.CompletedProcess
+    """
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            text=True,
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except FileNotFoundError:
+        errors.fail(f"{cmd[0]} is not installed or not on PATH")
+    except PermissionError:
+        errors.fail(f"Permission denied while running: {' '.join(cmd)}")
+    except Exception as exc:
+        # Catch-all — no raw tracebacks should ever leak
+        errors.fail(f"Unexpected error running {cmd[0]}: {exc}")
+
+    if check and result.returncode != 0:
+        detail = result.stderr.strip() or result.stdout.strip() or "unknown error"
+        tag = label or " ".join(cmd[:2])
+        errors.fail(f"{tag} failed: {detail}")
+
+    return result
+
+
+# ── Git operations ────────────────────────────────────────────────────
+
+def git_init(path: Path) -> None:
+    """Initialize a git repository at *path*."""
+    _run(["git", "init"], cwd=path, label="git init")
+    errors.success("Git initialized")
+
+
+def git_add(path: Path, *targets: str) -> None:
+    """Stage files.  Pass '.' to stage everything."""
+    _run(["git", "add", *targets], cwd=path, label="git add")
+
+
+def git_commit(path: Path, message: str) -> None:
+    """Create a commit with *message*."""
+    _run(["git", "commit", "-m", message], cwd=path, label="git commit")
+    errors.success("Initial commit")
+
+
+def git_push(path: Path, branch: str) -> None:
+    """Push to origin with upstream tracking."""
+    _run(["git", "push", "-u", "origin", branch], cwd=path, label="git push")
+    errors.success(f"Pushed to {branch}")
+
+
+def git_branch_current(path: Path, default: str = "main") -> str:
+    """Return the current branch name, falling back to *default*."""
+    result = _run(
+        ["git", "branch", "--show-current"],
+        cwd=path,
+        check=False,
+        label="git branch",
+    )
+    branch = result.stdout.strip() if result.returncode == 0 else ""
+    return branch or default
+
+
+def git_has_remote(path: Path, name: str = "origin") -> bool:
+    """Check whether a git remote named *name* already exists."""
+    result = _run(
+        ["git", "remote", "get-url", name],
+        cwd=path,
+        check=False,
+        label="git remote",
+    )
+    return result.returncode == 0
+
+
+# ── GitHub CLI operations ─────────────────────────────────────────────
+
+def gh_repo_create_clone(
+    name: str,
+    *,
+    visibility: str = "private",
+    clone_into: Path | None = None,
+) -> None:
+    """
+    Create a remote repo and clone it locally.
+
+    Used when the target directory does NOT exist or is EMPTY.
+    """
+    vis_flag = "--public" if visibility == "public" else "--private"
+    cmd = ["gh", "repo", "create", name, vis_flag, "--clone"]
+
+    if clone_into is not None:
+        # gh repo create <name> --clone clones into ./<name>
+        # We run it from the parent so the folder lands at the right spot.
+        _run(cmd, cwd=clone_into.parent, label="gh repo create --clone")
+    else:
+        _run(cmd, label="gh repo create --clone")
+
+    errors.success(f"GitHub repository created ({visibility})")
+
+
+def gh_repo_create_source(
+    path: Path,
+    name: str,
+    *,
+    visibility: str = "private",
+    push: bool = True,
+) -> None:
+    """
+    Create a remote repo from an existing local repo.
+
+    Used when the target directory already has files / is git-initialized.
+    """
+    vis_flag = "--public" if visibility == "public" else "--private"
+    cmd = ["gh", "repo", "create", name, vis_flag, "--source=."]
+    if push:
+        cmd.append("--push")
+
+    _run(cmd, cwd=path, label="gh repo create --source")
+    errors.success(f"GitHub repository created ({visibility})")
+
+
+def gh_repo_exists(name: str) -> bool:
+    """Check whether a remote repository with *name* already exists."""
+    result = _run(
+        ["gh", "repo", "view", name],
+        check=False,
+        label="gh repo view",
+    )
+    return result.returncode == 0

naissance/main.py

@@ -0,0 +1,14 @@
+"""
+main.py — Thin wrapper so `python main.py <args>` still works.
+"""
+
+from naissance.cli import parse_args
+from naissance.core import run
+
+
+def main():
+    run(parse_args())
+
+
+if __name__ == "__main__":
+    main()

naissance/path_resolver.py

@@ -0,0 +1,62 @@
+"""
+path_resolver.py — Resolve CLI input to a concrete (Path, repo_name) pair.
+
+Resolution rules:
+    naissance horizon           → CWD / "horizon",       repo_name = "horizon"
+    naissance code/horizon      → CWD / "code/horizon",  repo_name = "horizon"
+    naissance .                 → CWD,                   repo_name = CWD folder name
+    naissance "C:\\x\\y" --apath → Path("C:\\x\\y"),       repo_name = "y"
+"""
+
+from pathlib import Path
+
+from naissance import errors
+
+
+def resolve(repo_name: str, *, apath: bool = False) -> tuple[Path, str]:
+    """
+    Resolve *repo_name* into an absolute Path and a clean repo name.
+
+    Parameters
+    ----------
+    repo_name : str
+        The raw positional argument from the CLI.
+    apath : bool
+        If True, treat *repo_name* as an absolute path.
+
+    Returns
+    -------
+    (resolved_path, repo_name)
+        The fully-resolved directory path and the repository name
+        (last component of the path).
+    """
+    raw = repo_name.strip().strip('"').strip("'")
+
+    # ── Dot notation: use CWD itself ──────────────────────────────────
+    if raw in (".", "./", ".\\"):
+        resolved = Path.cwd().resolve()
+        name = resolved.name
+        return resolved, name
+
+    # ── Absolute path mode ────────────────────────────────────────────
+    if apath:
+        resolved = Path(raw).resolve()
+    else:
+        # Default: relative to CWD
+        resolved = (Path.cwd() / raw).resolve()
+
+    name = resolved.name
+
+    if not name:
+        errors.fail(f"Could not determine repository name from path: {resolved}")
+
+    # Validate that the *parent* directory exists (the repo dir itself
+    # may be created later).  For absolute paths the parent must exist;
+    # for relative paths CWD is always valid so this is a safety net.
+    parent = resolved.parent
+    if not parent.exists():
+        errors.fail(f"Parent directory does not exist: {parent}")
+    if parent.exists() and not parent.is_dir():
+        errors.fail(f"Parent path is not a directory: {parent}")
+
+    return resolved, name

naissance-2.0.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: naissance
+Version: 2.0.0
+Summary: Git Repository Genesis Utility
+License: MIT
+Project-URL: Homepage, https://github.com/DODO-unique/Naissance
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# Naissance
+
+> *A more dramatic Git Repository Genesis Utility.*
+
+Naissance creates both local and remote repositories in one shot. No context switching between terminal and browser — just run one command and your repo is alive.
+
+<!-- ![Naissance Demo](./docs/demo.gif) -->
+
+
+### Philosophy
+
+Naissance is meant to **get out of the way**. The goal is always to minimize friction between "I want a repo" and "the repo exists." No prompts, no decisions at runtime, no context switching. You type one command, naissance handles the rest, and you're already writing code. Every design choice should serve this principle.
+
+<!-- TODO: Add hero banner/screenshot here -->
+
+---
+
+## Installation
+
+```bash
+# Clone and install
+git clone https://github.com/DODO-unique/Naissance.git
+cd Naissance
+pip install .
+```
+
+### Requirements 
+
+- Python ≥ 3.10
+- [Git](https://git-scm.com/)
+- [GitHub CLI (`gh`)](https://cli.github.com/) — authenticated via `gh auth login`
+
+> **Note:** `gh` is a crucial dependency — naissance uses it to create remote repositories. Without it, the tool cannot function. If `gh` is not installed, naissance will detect this at startup and suggest how to install it:
+> ```
+>   ⨯ GitHub CLI (gh) is not installed or not on PATH
+> ```
+> Install it from [cli.github.com](https://cli.github.com/), then run `gh auth login` to authenticate.
+
+---
+
+## Quick Start
+
+```bash
+# Create a new repo "horizon" in the current directory
+naissance horizon
+
+# That's it. Local + remote, done.
+```
+
+<!-- TODO: Add terminal recording / screenshot of output here -->
+<!-- ![Quick Start Output](./docs/quickstart.png) -->
+
+### What happens
+
+```
+┼─────────────────────────────────────────────────────────────┼
+|       _   __      _
+|      / | / /___ _(_)_____________ _____  ________
+|     /  |/ / __ `/ / ___/ ___/ __ `/ __ \/ ___/ _ \
+|    / /|  / /_/ / (__  |__  ) /_/ / / / / /__/  __/
+|   /_/ |_/\__,_/_/____/____/\__,_/_/ /_/\___/\___/
+|                                        v2.0.0
+|
+|            Git Repository Genesis Utility
+┼─────────────────────────────────────────────────────────────┼
+
+  Birthing repository...
+
+  ✓ git found
+  ✓ gh authenticated
+  ✓ Path resolved: C:\Code\horizon
+  ✓ Directory created
+  ✓ GitHub repository created (private)
+  ✓ Git initialized
+  ✓ README.md
+  ✓ .gitignore
+  ✓ Initial commit
+  ✓ Pushed to main
+
+  ✨ horizon is alive.
+```
+
+---
+
+## Usage
+
+```bash
+naissance <repo_name> [--apath] [--name NAME] [--public]
+```
+
+| Flag | Description |
+|---|---|
+| `repo_name` | Name or path of the repo. Resolved relative to CWD. Use `.` for current directory. |
+| `--apath` | Treat `repo_name` as an absolute path |
+| `--name NAME` | Override the remote repository name (defaults to directory name) |
+| `--public` | Create the remote repo as public (default: private) |
+| `-v, --version` | Show version |
+
+### Examples
+
+```bash
+# Relative path — creates ./horizon
+naissance horizon
+
+# Nested path — creates ./projects/horizon
+naissance projects/horizon
+
+# Current directory — uses folder name as repo name
+naissance .
+
+# Absolute path
+naissance "C:\Code\horizon" --apath
+
+# Different remote name than the directory
+naissance horizon --name my-cool-project
+
+# Public repo
+naissance horizon --public
+```
+
+---
+
+## How It Works
+
+Naissance detects the state of the target directory and adapts:
+
+| State | What naissance does |
+|---|---|
+| **Doesn't exist** | Creates the directory → `gh repo create --clone` → scaffolds README + .gitignore → commits → pushes |
+| **Empty directory** | `git init` → scaffolds → `gh repo create --source` → pushes |
+| **Has files, no git** | `git init` → scaffolds → stages all → commits → `gh repo create --source` → pushes |
+| **Already git-initialized** | Checks no remote exists → `gh repo create --source` → pushes |
+
+All decisions (visibility, scaffold files, commit message) are driven by [`defaults.yml`](./defaults.yml) — **zero interactive prompts** during execution.
+
+---
+
+## Configuration
+
+Edit `defaults.yml` next to the package to change defaults:
+
+```yaml
+version: "2.0.0"
+visibility: "private"          # "private" or "public"
+create_readme: true
+create_gitignore: true
+prompt_description: false
+default_branch: "main"
+initial_commit_message: "initial commit"
+```
+
+---
+
+## Error Handling
+
+Naissance never leaks raw tracebacks. All errors are caught and displayed cleanly:
+
+```
+  ⨯ git is not installed or not on PATH
+  ⨯ GitHub CLI is not authenticated. Run: gh auth login
+  ⨯ Remote repository already exists: horizon
+  ⨯ Permission denied: C:\Protected\path
+```
+
+---
+
+## License
+
+[MIT](./LICENSE)
+
+---
+
+## See Also
+
+- [CHANGELOG.md](./CHANGELOG.md) — Version history
+- [ROADMAP.md](./ROADMAP.md) — What's coming next
+- [KNOWN_ISSUES.md](./KNOWN_ISSUES.md) — Bugs and workarounds

naissance-2.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+naissance/__init__.py,sha256=k6FrpPbBT4qc4UaIJ0kEP2dmTffqu4HH54MxnriLZVw,75
+naissance/__main__.py,sha256=bFjYJ-yK5LcwFu9B6NiCsirX25944Orq2DsYEl4d99A,134
+naissance/cli.py,sha256=gPPxNMGcVgEKehlEZI5DfnSii4ZvxbfPczsTHO80Lns,1748
+naissance/core.py,sha256=5vwxo66gqZH8YZDvkgThENSKva5L0HzKH_nK7XA9w4U,8856
+naissance/errors.py,sha256=QB1dg6iDayjZQonMRtE8kb3_Wap-2u3r9Q14EKXk23g,3166
+naissance/git_ops.py,sha256=AVtGWG0vyJU3l87D4QEc5OIwIXtNfy3a1yqAjNomM3I,5026
+naissance/main.py,sha256=PoUCMlYcTu69uqZ63txJQqk-4W8xrCSzwZgndRcp8SI,218
+naissance/path_resolver.py,sha256=pMsN3gk3ohSBEjeMblZiVP1IlvqQk45ygonxO5osP6Q,2224
+naissance-2.0.0.dist-info/licenses/LICENSE,sha256=hDNBiwtJIJpBVn9UydxtyCD0UWfgeL_DSLF4VeuMZ_o,1071
+naissance-2.0.0.dist-info/METADATA,sha256=6c1twIycYIT0wjywMgY1_v-Z1Ct99EKj9tcwF6pA6G0,5770
+naissance-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+naissance-2.0.0.dist-info/entry_points.txt,sha256=h5g7DSITd1UpnKtZcWf4Io3cF7h5KN4oXmSoTXnrst4,50
+naissance-2.0.0.dist-info/top_level.txt,sha256=ZOhXtHEDhA2i6Aa_pgAvGOjrg70We8AOn2CozMUiaSI,10
+naissance-2.0.0.dist-info/RECORD,,

naissance-2.0.0.dist-info/WHEEL

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

naissance-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+naissance = naissance.main:main

naissance-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2026 DODO-unique
+
+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.

naissance-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+naissance