smart-gitignore 0.1.0__tar.gz

smart_gitignore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+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.

smart_gitignore-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: smart-gitignore
+Version: 0.1.0
+Summary: Scan a project and auto-generate sensible .gitignore rules for logs, env files, venvs, node_modules and more.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/smart-gitignore
+Keywords: git,gitignore,cli,developer-tools
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# smart-gitignore
+
+Scan a project directory and auto-generate sensible `.gitignore` rules —
+logs, `.env` files, virtual environments, `node_modules`, caches, build
+artifacts, and OS junk — in a single command.
+
+Built for a very common beginner mistake: forgetting to add `.gitignore`
+*before* the first commit, then accidentally pushing log files, secrets,
+or dependency folders into the repo.
+
+## Why
+
+Most `.gitignore` generators (gitignore.io, `gig`, etc.) ask you to pick a
+language/framework and give you a template. `smart-gitignore` instead
+**looks at what's actually sitting in your project folder** and suggests
+rules based on real files it finds — logs, envs, venvs, dependency
+folders — regardless of language.
+
+It also does something most generators don't: it checks whether any of
+those files are **already tracked by git**, and warns you that adding a
+`.gitignore` rule alone won't remove them from the repo or its history.
+
+## Install
+
+```bash
+pip install smart-gitignore
+```
+
+(Or, until published: clone this repo and run `pip install .`)
+
+## Usage
+
+```bash
+# Preview what would be added, without touching any files
+smart-gitignore /path/to/project --dry-run
+
+# Scan current directory and write changes (with confirmation prompt)
+smart-gitignore
+
+# Skip the confirmation prompt for .gitignore writes
+smart-gitignore --yes
+
+# Also run git rm --cached automatically on already-tracked matches
+# (still separate from --yes; off by default)
+smart-gitignore --auto-untrack
+
+# Also detect and ignore images/video/audio (off by default —
+# many projects intentionally commit media assets)
+smart-gitignore --include-media
+```
+
+### Example output
+
+```
+Scanning /home/you/my-project ...
+
+Detected files that should probably be ignored:
+
+  [Logs]
+    *.log
+    logs/
+  [Environment / Secrets]
+    .env
+  [Python Virtual Environments]
+    venv/
+
+⚠ WARNING: these files are already tracked by git.
+  Adding a pattern to .gitignore will NOT remove them from the repo
+  or from your git history. The fix is to untrack them:
+
+    git rm --cached "app.log"    # matched pattern: *.log
+
+Append these rules to .gitignore? [y/N] y
+Done. Updated .gitignore
+
+Run 'git rm --cached' on the 1 already-tracked file(s) shown above now? [y/N] y
+
+Untracked 1 file(s):
+    git rm --cached "app.log"  done
+
+  These files still exist on disk — only removed from git's index.
+  Commit this to finish: git commit -m "Stop tracking ignored files"
+```
+
+Writing `.gitignore` and untracking already-committed files are **two
+separate confirmations** — saying yes to one never silently triggers the
+other. Pass `--auto-untrack` to skip the second prompt if you're scripting
+this (e.g. in CI or a setup script).
+
+## What it detects by default
+
+| Category | Examples |
+|---|---|
+| Logs | `*.log`, `logs/` |
+| Environment / secrets | `.env`, `.env.local` |
+| Python virtual environments | `venv/`, `.venv/`, `env/` |
+| Python cache | `__pycache__/`, `*.pyc` |
+| Node dependencies | `node_modules/` |
+| Build artifacts | `dist/`, `build/`, `target/` |
+| OS junk | `.DS_Store`, `Thumbs.db` |
+| Editor/IDE | `.vscode/`, `.idea/` |
+
+Images, video, and audio are **opt-in only** (`--include-media`) since
+many repos legitimately track media assets (docs, icons, website content).
+
+## Important: this doesn't rewrite git history
+
+`smart-gitignore` only edits `.gitignore`. If a file is already committed,
+ignoring it going forward requires:
+
+```bash
+git rm --cached path/to/file
+git commit -m "Stop tracking file"
+```
+
+If sensitive data (API keys, passwords) was ever committed, `git rm --cached`
+is **not enough** — it's still in old commits. Use
+[`git filter-repo`](https://github.com/newren/git-filter-repo) or the
+[BFG Repo-Cleaner](https://rtyley.github.io/bfg-repo-cleaner/) to scrub history,
+and rotate/revoke the leaked credentials regardless.
+
+## Contributing
+
+PRs welcome — especially additional rule categories in `rules.py`
+(other language ecosystems, other build tools, etc.).
+
+## License
+
+MIT

smart_gitignore-0.1.0/README.md

@@ -0,0 +1,129 @@
+# smart-gitignore
+
+Scan a project directory and auto-generate sensible `.gitignore` rules —
+logs, `.env` files, virtual environments, `node_modules`, caches, build
+artifacts, and OS junk — in a single command.
+
+Built for a very common beginner mistake: forgetting to add `.gitignore`
+*before* the first commit, then accidentally pushing log files, secrets,
+or dependency folders into the repo.
+
+## Why
+
+Most `.gitignore` generators (gitignore.io, `gig`, etc.) ask you to pick a
+language/framework and give you a template. `smart-gitignore` instead
+**looks at what's actually sitting in your project folder** and suggests
+rules based on real files it finds — logs, envs, venvs, dependency
+folders — regardless of language.
+
+It also does something most generators don't: it checks whether any of
+those files are **already tracked by git**, and warns you that adding a
+`.gitignore` rule alone won't remove them from the repo or its history.
+
+## Install
+
+```bash
+pip install smart-gitignore
+```
+
+(Or, until published: clone this repo and run `pip install .`)
+
+## Usage
+
+```bash
+# Preview what would be added, without touching any files
+smart-gitignore /path/to/project --dry-run
+
+# Scan current directory and write changes (with confirmation prompt)
+smart-gitignore
+
+# Skip the confirmation prompt for .gitignore writes
+smart-gitignore --yes
+
+# Also run git rm --cached automatically on already-tracked matches
+# (still separate from --yes; off by default)
+smart-gitignore --auto-untrack
+
+# Also detect and ignore images/video/audio (off by default —
+# many projects intentionally commit media assets)
+smart-gitignore --include-media
+```
+
+### Example output
+
+```
+Scanning /home/you/my-project ...
+
+Detected files that should probably be ignored:
+
+  [Logs]
+    *.log
+    logs/
+  [Environment / Secrets]
+    .env
+  [Python Virtual Environments]
+    venv/
+
+⚠ WARNING: these files are already tracked by git.
+  Adding a pattern to .gitignore will NOT remove them from the repo
+  or from your git history. The fix is to untrack them:
+
+    git rm --cached "app.log"    # matched pattern: *.log
+
+Append these rules to .gitignore? [y/N] y
+Done. Updated .gitignore
+
+Run 'git rm --cached' on the 1 already-tracked file(s) shown above now? [y/N] y
+
+Untracked 1 file(s):
+    git rm --cached "app.log"  done
+
+  These files still exist on disk — only removed from git's index.
+  Commit this to finish: git commit -m "Stop tracking ignored files"
+```
+
+Writing `.gitignore` and untracking already-committed files are **two
+separate confirmations** — saying yes to one never silently triggers the
+other. Pass `--auto-untrack` to skip the second prompt if you're scripting
+this (e.g. in CI or a setup script).
+
+## What it detects by default
+
+| Category | Examples |
+|---|---|
+| Logs | `*.log`, `logs/` |
+| Environment / secrets | `.env`, `.env.local` |
+| Python virtual environments | `venv/`, `.venv/`, `env/` |
+| Python cache | `__pycache__/`, `*.pyc` |
+| Node dependencies | `node_modules/` |
+| Build artifacts | `dist/`, `build/`, `target/` |
+| OS junk | `.DS_Store`, `Thumbs.db` |
+| Editor/IDE | `.vscode/`, `.idea/` |
+
+Images, video, and audio are **opt-in only** (`--include-media`) since
+many repos legitimately track media assets (docs, icons, website content).
+
+## Important: this doesn't rewrite git history
+
+`smart-gitignore` only edits `.gitignore`. If a file is already committed,
+ignoring it going forward requires:
+
+```bash
+git rm --cached path/to/file
+git commit -m "Stop tracking file"
+```
+
+If sensitive data (API keys, passwords) was ever committed, `git rm --cached`
+is **not enough** — it's still in old commits. Use
+[`git filter-repo`](https://github.com/newren/git-filter-repo) or the
+[BFG Repo-Cleaner](https://rtyley.github.io/bfg-repo-cleaner/) to scrub history,
+and rotate/revoke the leaked credentials regardless.
+
+## Contributing
+
+PRs welcome — especially additional rule categories in `rules.py`
+(other language ecosystems, other build tools, etc.).
+
+## License
+
+MIT

smart_gitignore-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smart-gitignore"
+version = "0.1.0"
+description = "Scan a project and auto-generate sensible .gitignore rules for logs, env files, venvs, node_modules and more."
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+authors = [
+    { name = "Your Name" }
+]
+keywords = ["git", "gitignore", "cli", "developer-tools"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
+[project.scripts]
+smart-gitignore = "smart_gitignore.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/smart-gitignore"

smart_gitignore-0.1.0/setup.cfg

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

smart_gitignore-0.1.0/smart_gitignore/__init__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+__all__ = ["main"]
+__version__ = "0.1.0"

smart_gitignore-0.1.0/smart_gitignore/cli.py

@@ -0,0 +1,307 @@
+"""
+cli.py
+------
+The actual smart-gitignore command.
+
+Flow:
+  1. Walk the target directory (skipping .git) and collect:
+       - every file extension present
+       - every directory name present
+       - every exact filename present
+  2. Compare against DEFAULT_RULES (and MEDIA_RULES if --include-media).
+  3. Work out which patterns are genuinely new (not already in .gitignore).
+  4. If any matching files are ALREADY tracked by git, warn the user —
+     adding a pattern to .gitignore does NOT untrack files that are
+     already committed. This is the #1 confusion beginners have.
+  5. Show a preview. Write only on confirmation (or --yes).
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from datetime import date
+from fnmatch import fnmatch
+from pathlib import Path
+
+from .rules import DEFAULT_RULES, MEDIA_RULES
+
+
+def warn_media_skipped(extensions, dirnames, filenames):
+    """
+    If media files exist in the project but --include-media wasn't passed,
+    surface that immediately as a warning — not buried in the README.
+    We deliberately do NOT ignore media by default because many projects
+    intentionally commit images/icons/docs, and silently suggesting to
+    ignore them could make someone lose tracked assets.
+    """
+    matched = match_rules(MEDIA_RULES, extensions, dirnames, filenames)
+    if not matched:
+        return
+    total_examples = []
+    for rule in matched:
+        total_examples.append(rule.name.replace(" (opt-in)", ""))
+    print(f"{WARN_PREFIX} found media files ({', '.join(total_examples)}) but skipping them by default.")
+    print("  Media is often committed on purpose (docs, icons, website assets), so this tool")
+    print("  will never silently suggest ignoring it. Re-run with --include-media if you")
+    print("  actually want these ignored.\n")
+
+HEADER = "# --- Added by smart-gitignore on {date} ---"
+
+WARN_PREFIX = "⚠ WARNING:"
+
+
+def scan_directory(root: Path):
+    """Walk the directory tree and collect extensions, dirnames, filenames."""
+    extensions = set()
+    dirnames = set()
+    filenames = set()
+
+    for current_root, dirs, files in os.walk(root):
+        # never descend into .git
+        if ".git" in dirs:
+            dirs.remove(".git")
+
+        for d in dirs:
+            dirnames.add(d)
+
+        for f in files:
+            filenames.add(f)
+            ext = Path(f).suffix
+            if ext:
+                extensions.add(ext)
+
+    return extensions, dirnames, filenames
+
+
+def match_rules(rules, extensions, dirnames, filenames):
+    """Return the list of Rule objects that apply to what's on disk."""
+    matched = []
+    for rule in rules:
+        hit = False
+        if rule.match_extensions and extensions.intersection(rule.match_extensions):
+            hit = True
+        if rule.match_dirnames and dirnames.intersection(rule.match_dirnames):
+            hit = True
+        if rule.match_filenames and filenames.intersection(rule.match_filenames):
+            hit = True
+        if hit:
+            matched.append(rule)
+    return matched
+
+
+def load_existing_gitignore(path: Path):
+    if not path.exists():
+        return []
+    return [line.rstrip("\n") for line in path.read_text(encoding="utf-8").splitlines()]
+
+
+def compute_new_patterns(matched_rules, existing_lines):
+    existing_set = set(line.strip() for line in existing_lines)
+    new_by_category = {}
+    for rule in matched_rules:
+        fresh = [p for p in rule.patterns if p not in existing_set]
+        if fresh:
+            new_by_category[rule.name] = fresh
+    return new_by_category
+
+
+def is_git_repo(root: Path) -> bool:
+    return (root / ".git").exists()
+
+
+def get_tracked_files(root: Path):
+    """Return the list of files git already tracks, or [] if not a repo / git missing."""
+    if not is_git_repo(root):
+        return []
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(root), "ls-files"],
+            capture_output=True, text=True, check=True,
+        )
+        return result.stdout.splitlines()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return []
+
+
+def find_already_tracked_matches(tracked_files, new_by_category):
+    """Check whether any already-tracked file would match one of our new patterns."""
+    all_patterns = [p for patterns in new_by_category.values() for p in patterns]
+    warnings = []
+    for f in tracked_files:
+        basename = os.path.basename(f)
+        for pattern in all_patterns:
+            # directory-style pattern e.g. "venv/" -> check path prefix
+            if pattern.endswith("/"):
+                dirname = pattern.rstrip("/")
+                if f == dirname or f.startswith(dirname + "/") or ("/" + dirname + "/") in ("/" + f):
+                    warnings.append((f, pattern))
+                    break
+            else:
+                if fnmatch(basename, pattern) or fnmatch(f, pattern):
+                    warnings.append((f, pattern))
+                    break
+    return warnings
+
+
+def untrack_files(root: Path, warnings):
+    """
+    Actually run `git rm --cached` for each already-tracked file that matches
+    a new .gitignore pattern. Only ever called after the user explicitly
+    typed 'y' — this tool never runs git commands without that confirmation.
+    Returns (succeeded, failed) lists of filenames.
+    """
+    succeeded, failed = [], []
+    for f, _pattern in warnings:
+        try:
+            subprocess.run(
+                ["git", "-C", str(root), "rm", "--cached", "--quiet", f],
+                check=True, capture_output=True, text=True,
+            )
+            succeeded.append(f)
+        except subprocess.CalledProcessError as e:
+            failed.append((f, e.stderr.strip() or str(e)))
+    return succeeded, failed
+
+
+def build_output_block(new_by_category):
+    lines = [HEADER.format(date=date.today().isoformat())]
+    for category, patterns in new_by_category.items():
+        lines.append(f"\n# {category}")
+        lines.extend(patterns)
+    return "\n".join(lines) + "\n"
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="smart-gitignore",
+        description="Scan a project and auto-add sensible .gitignore rules "
+                     "(logs, env files, venvs, node_modules, caches, etc.)."
+    )
+    parser.add_argument("path", nargs="?", default=".", help="Project directory (default: current directory)")
+    parser.add_argument("--include-media", action="store_true",
+                         help="Also detect and ignore images/video/audio files (off by default — "
+                              "many projects intentionally commit media assets).")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would change, write nothing.")
+    parser.add_argument("-y", "--yes", action="store_true", help="Write .gitignore changes without prompting.")
+    parser.add_argument("--auto-untrack", action="store_true",
+                         help="Also run 'git rm --cached' on already-tracked matches without "
+                              "prompting. Off by default — untracking is asked for separately "
+                              "from writing .gitignore, since it touches your git index.")
+    args = parser.parse_args(argv)
+
+    root = Path(args.path).resolve()
+    if not root.exists():
+        print(f"Error: path '{root}' does not exist.")
+        sys.exit(1)
+
+    rules = list(DEFAULT_RULES)
+    if args.include_media:
+        rules += MEDIA_RULES
+
+    print(f"Scanning {root} ...")
+    extensions, dirnames, filenames = scan_directory(root)
+    matched_rules = match_rules(rules, extensions, dirnames, filenames)
+
+    # Design decision #1, surfaced live: warn about skipped media instead of
+    # just documenting it in the README.
+    if not args.include_media:
+        warn_media_skipped(extensions, dirnames, filenames)
+
+    gitignore_path = root / ".gitignore"
+    existing_lines = load_existing_gitignore(gitignore_path)
+    new_by_category = compute_new_patterns(matched_rules, existing_lines)
+
+    if not new_by_category:
+        print("Nothing new to add — your .gitignore already covers what's here, "
+              "or no risky file types were found.")
+        return
+
+    print("\nDetected files that should probably be ignored:\n")
+    for category, patterns in new_by_category.items():
+        print(f"  [{category}]")
+        for p in patterns:
+            print(f"    {p}")
+    print()
+
+    # Design decision #3, surfaced live: files already committed need manual
+    # untracking — a .gitignore rule alone changes nothing for them.
+    tracked_files = get_tracked_files(root)
+    already_tracked_hit = False
+    tracked_warnings = []
+    if tracked_files:
+        tracked_warnings = find_already_tracked_matches(tracked_files, new_by_category)
+        if tracked_warnings:
+            already_tracked_hit = True
+            print(f"{WARN_PREFIX} these files are already tracked by git.")
+            print("  Adding a pattern to .gitignore will NOT remove them from the repo")
+            print("  or from your git history. The fix is to untrack them:\n")
+            for f, pattern in tracked_warnings[:20]:
+                print(f"    git rm --cached \"{f}\"    # matched pattern: {pattern}")
+            if len(tracked_warnings) > 20:
+                print(f"    ... and {len(tracked_warnings) - 20} more")
+            print("\n  (If any of these ever contained secrets, git rm --cached is not")
+            print("  enough — they're still in old commits. Use git filter-repo or the")
+            print("  BFG Repo-Cleaner, and rotate the leaked credentials regardless.)\n")
+
+    if args.dry_run:
+        print("(dry run — no files were changed)")
+        return
+
+    # Design decision #2, surfaced live: this tool never runs a git command
+    # or touches files beyond what you explicitly confirm. Writing .gitignore
+    # and untracking already-committed files are two separate actions with
+    # two separate y/n prompts below — saying yes to one never triggers the other.
+    print(f"{WARN_PREFIX} this tool only changes what you explicitly confirm.")
+    print("  Writing .gitignore and untracking files are asked about separately.\n")
+
+    wrote_gitignore = False
+    if not args.yes:
+        answer = input(f"Append these rules to {gitignore_path}? [y/N] ").strip().lower()
+        if answer == "y":
+            wrote_gitignore = True
+        else:
+            print("Cancelled — .gitignore was not changed.")
+    else:
+        wrote_gitignore = True
+
+    if wrote_gitignore:
+        block = build_output_block(new_by_category)
+        with open(gitignore_path, "a", encoding="utf-8") as f:
+            if existing_lines:
+                f.write("\n")
+            f.write(block)
+        print(f"Done. Updated {gitignore_path}")
+
+    # Separate, explicit y/n for the destructive action: untracking files
+    # that are already committed. Never bundled with the prompt above unless
+    # the user opted in via --auto-untrack.
+    if already_tracked_hit:
+        print()
+        if args.auto_untrack:
+            run_untrack = True
+        else:
+            reply = input(
+                f"Run 'git rm --cached' on the {len(tracked_warnings)} already-tracked "
+                f"file(s) shown above now? [y/N] "
+            ).strip().lower()
+            run_untrack = (reply == "y")
+
+        if run_untrack:
+            succeeded, failed = untrack_files(root, tracked_warnings)
+            if succeeded:
+                print(f"\nUntracked {len(succeeded)} file(s):")
+                for f in succeeded:
+                    print(f"    git rm --cached \"{f}\"  done")
+                print("\n  These files still exist on disk — only removed from git's index.")
+                print("  Commit this to finish: git commit -m \"Stop tracking ignored files\"")
+            if failed:
+                print(f"\nFailed to untrack {len(failed)} file(s):")
+                for f, err in failed:
+                    print(f"    {f}: {err}")
+        else:
+            print("Skipped — no files were untracked. You can run the commands above manually anytime.")
+
+
+if __name__ == "__main__":
+    main()

smart_gitignore-0.1.0/smart_gitignore/rules.py

@@ -0,0 +1,94 @@
+"""
+rules.py
+--------
+Defines the categories smart-gitignore knows how to detect, and the
+patterns it will write into .gitignore for each one.
+
+Design note:
+Every category is "safe by default" — i.e. things that are almost NEVER
+meant to be committed (logs, envs, venvs, dependency folders, caches).
+
+Media files (images/video/audio) are kept OUT of the default set and only
+included when the user explicitly passes --include-media, because many
+projects legitimately commit images (docs, website assets, icons) and we
+never want to silently suggest ignoring something that belongs in the repo.
+"""
+
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass
+class Rule:
+    name: str                 # Human readable category name
+    patterns: List[str]       # Patterns to add to .gitignore
+    match_extensions: List[str] = None   # File extensions that trigger this rule
+    match_dirnames: List[str] = None     # Directory names that trigger this rule
+    match_filenames: List[str] = None    # Exact filenames that trigger this rule
+
+
+DEFAULT_RULES: List[Rule] = [
+    Rule(
+        name="Logs",
+        patterns=["*.log", "*.log.*", "logs/", "npm-debug.log*", "yarn-debug.log*", "yarn-error.log*"],
+        match_extensions=[".log"],
+        match_dirnames=["logs"],
+    ),
+    Rule(
+        name="Environment / Secrets",
+        patterns=[".env", ".env.local", ".env.*.local", "*.env"],
+        match_filenames=[".env"],
+        match_extensions=[".env"],
+    ),
+    Rule(
+        name="Python Virtual Environments",
+        patterns=["venv/", ".venv/", "env/", "ENV/", "virtualenv/"],
+        match_dirnames=["venv", ".venv", "env", "ENV", "virtualenv"],
+    ),
+    Rule(
+        name="Python Cache",
+        patterns=["__pycache__/", "*.pyc", "*.pyo", "*.pyd", ".pytest_cache/", ".mypy_cache/"],
+        match_extensions=[".pyc", ".pyo", ".pyd"],
+        match_dirnames=["__pycache__", ".pytest_cache", ".mypy_cache"],
+    ),
+    Rule(
+        name="Node.js Dependencies",
+        patterns=["node_modules/", ".npm/", ".yarn/"],
+        match_dirnames=["node_modules"],
+    ),
+    Rule(
+        name="Build Artifacts",
+        patterns=["dist/", "build/", "*.egg-info/", "target/", "out/"],
+        match_dirnames=["dist", "build", "target", "out"],
+    ),
+    Rule(
+        name="OS Junk Files",
+        patterns=[".DS_Store", "Thumbs.db", "desktop.ini"],
+        match_filenames=[".DS_Store", "Thumbs.db", "desktop.ini"],
+    ),
+    Rule(
+        name="Editor / IDE",
+        patterns=[".vscode/", ".idea/", "*.sublime-workspace", "*.swp"],
+        match_dirnames=[".vscode", ".idea"],
+        match_extensions=[".swp"],
+    ),
+]
+
+# Opt-in only — see design note above.
+MEDIA_RULES: List[Rule] = [
+    Rule(
+        name="Media - Images (opt-in)",
+        patterns=["*.png", "*.jpg", "*.jpeg", "*.gif", "*.bmp", "*.webp"],
+        match_extensions=[".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"],
+    ),
+    Rule(
+        name="Media - Video (opt-in)",
+        patterns=["*.mp4", "*.mov", "*.avi", "*.mkv", "*.wmv"],
+        match_extensions=[".mp4", ".mov", ".avi", ".mkv", ".wmv"],
+    ),
+    Rule(
+        name="Media - Audio (opt-in)",
+        patterns=["*.mp3", "*.wav", "*.flac", "*.aac"],
+        match_extensions=[".mp3", ".wav", ".flac", ".aac"],
+    ),
+]

smart_gitignore-0.1.0/smart_gitignore.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: smart-gitignore
+Version: 0.1.0
+Summary: Scan a project and auto-generate sensible .gitignore rules for logs, env files, venvs, node_modules and more.
+Author: Your Name
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/smart-gitignore
+Keywords: git,gitignore,cli,developer-tools
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# smart-gitignore
+
+Scan a project directory and auto-generate sensible `.gitignore` rules —
+logs, `.env` files, virtual environments, `node_modules`, caches, build
+artifacts, and OS junk — in a single command.
+
+Built for a very common beginner mistake: forgetting to add `.gitignore`
+*before* the first commit, then accidentally pushing log files, secrets,
+or dependency folders into the repo.
+
+## Why
+
+Most `.gitignore` generators (gitignore.io, `gig`, etc.) ask you to pick a
+language/framework and give you a template. `smart-gitignore` instead
+**looks at what's actually sitting in your project folder** and suggests
+rules based on real files it finds — logs, envs, venvs, dependency
+folders — regardless of language.
+
+It also does something most generators don't: it checks whether any of
+those files are **already tracked by git**, and warns you that adding a
+`.gitignore` rule alone won't remove them from the repo or its history.
+
+## Install
+
+```bash
+pip install smart-gitignore
+```
+
+(Or, until published: clone this repo and run `pip install .`)
+
+## Usage
+
+```bash
+# Preview what would be added, without touching any files
+smart-gitignore /path/to/project --dry-run
+
+# Scan current directory and write changes (with confirmation prompt)
+smart-gitignore
+
+# Skip the confirmation prompt for .gitignore writes
+smart-gitignore --yes
+
+# Also run git rm --cached automatically on already-tracked matches
+# (still separate from --yes; off by default)
+smart-gitignore --auto-untrack
+
+# Also detect and ignore images/video/audio (off by default —
+# many projects intentionally commit media assets)
+smart-gitignore --include-media
+```
+
+### Example output
+
+```
+Scanning /home/you/my-project ...
+
+Detected files that should probably be ignored:
+
+  [Logs]
+    *.log
+    logs/
+  [Environment / Secrets]
+    .env
+  [Python Virtual Environments]
+    venv/
+
+⚠ WARNING: these files are already tracked by git.
+  Adding a pattern to .gitignore will NOT remove them from the repo
+  or from your git history. The fix is to untrack them:
+
+    git rm --cached "app.log"    # matched pattern: *.log
+
+Append these rules to .gitignore? [y/N] y
+Done. Updated .gitignore
+
+Run 'git rm --cached' on the 1 already-tracked file(s) shown above now? [y/N] y
+
+Untracked 1 file(s):
+    git rm --cached "app.log"  done
+
+  These files still exist on disk — only removed from git's index.
+  Commit this to finish: git commit -m "Stop tracking ignored files"
+```
+
+Writing `.gitignore` and untracking already-committed files are **two
+separate confirmations** — saying yes to one never silently triggers the
+other. Pass `--auto-untrack` to skip the second prompt if you're scripting
+this (e.g. in CI or a setup script).
+
+## What it detects by default
+
+| Category | Examples |
+|---|---|
+| Logs | `*.log`, `logs/` |
+| Environment / secrets | `.env`, `.env.local` |
+| Python virtual environments | `venv/`, `.venv/`, `env/` |
+| Python cache | `__pycache__/`, `*.pyc` |
+| Node dependencies | `node_modules/` |
+| Build artifacts | `dist/`, `build/`, `target/` |
+| OS junk | `.DS_Store`, `Thumbs.db` |
+| Editor/IDE | `.vscode/`, `.idea/` |
+
+Images, video, and audio are **opt-in only** (`--include-media`) since
+many repos legitimately track media assets (docs, icons, website content).
+
+## Important: this doesn't rewrite git history
+
+`smart-gitignore` only edits `.gitignore`. If a file is already committed,
+ignoring it going forward requires:
+
+```bash
+git rm --cached path/to/file
+git commit -m "Stop tracking file"
+```
+
+If sensitive data (API keys, passwords) was ever committed, `git rm --cached`
+is **not enough** — it's still in old commits. Use
+[`git filter-repo`](https://github.com/newren/git-filter-repo) or the
+[BFG Repo-Cleaner](https://rtyley.github.io/bfg-repo-cleaner/) to scrub history,
+and rotate/revoke the leaked credentials regardless.
+
+## Contributing
+
+PRs welcome — especially additional rule categories in `rules.py`
+(other language ecosystems, other build tools, etc.).
+
+## License
+
+MIT

smart_gitignore-0.1.0/smart_gitignore.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+smart_gitignore/__init__.py
+smart_gitignore/cli.py
+smart_gitignore/rules.py
+smart_gitignore.egg-info/PKG-INFO
+smart_gitignore.egg-info/SOURCES.txt
+smart_gitignore.egg-info/dependency_links.txt
+smart_gitignore.egg-info/entry_points.txt
+smart_gitignore.egg-info/requires.txt
+smart_gitignore.egg-info/top_level.txt
+tests/test_cli.py

smart_gitignore-0.1.0/smart_gitignore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smart_gitignore-0.1.0/smart_gitignore.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+smart-gitignore = smart_gitignore.cli:main

smart_gitignore-0.1.0/smart_gitignore.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

smart_gitignore-0.1.0/smart_gitignore.egg-info/top_level.txt

@@ -0,0 +1 @@
+smart_gitignore

smart_gitignore-0.1.0/tests/test_cli.py

@@ -0,0 +1,201 @@
+"""
+test_cli.py
+-----------
+Automated tests for smart-gitignore. Run with:
+
+    pip install -e .[dev]
+    pytest -v
+
+Covers:
+  - directory scanning (extensions/dirnames/filenames detection)
+  - rule matching
+  - computing only-new patterns (no duplicate lines)
+  - detecting already-tracked files that match new patterns
+  - full end-to-end run against a real temporary git repo
+"""
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from smart_gitignore.cli import (
+    scan_directory,
+    match_rules,
+    compute_new_patterns,
+    find_already_tracked_matches,
+    main,
+)
+from smart_gitignore.rules import DEFAULT_RULES, MEDIA_RULES
+
+
+def make_git_repo(path: Path):
+    subprocess.run(["git", "init", "-q"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.email", "t@t.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=path, check=True)
+
+
+def git_commit_all(path: Path, message="commit"):
+    subprocess.run(["git", "add", "-A"], cwd=path, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", message], cwd=path, check=True)
+
+
+def git_ls_files(path: Path):
+    result = subprocess.run(
+        ["git", "ls-files"], cwd=path, capture_output=True, text=True, check=True
+    )
+    return result.stdout.splitlines()
+
+
+# ---------- unit tests ----------
+
+def test_scan_directory_detects_extensions_and_dirs(tmp_path):
+    (tmp_path / "app.log").touch()
+    (tmp_path / "main.py").touch()
+    (tmp_path / "venv").mkdir()
+    (tmp_path / ".env").touch()
+
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+
+    assert ".log" in extensions
+    assert ".py" in extensions
+    assert "venv" in dirnames
+    assert ".env" in filenames
+
+
+def test_scan_directory_skips_git_folder(tmp_path):
+    make_git_repo(tmp_path)
+    # .git contains lots of files/extensions internally; none should leak in
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+    assert ".git" not in dirnames
+
+
+def test_match_rules_logs(tmp_path):
+    (tmp_path / "debug.log").touch()
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+    matched = match_rules(DEFAULT_RULES, extensions, dirnames, filenames)
+    names = [r.name for r in matched]
+    assert "Logs" in names
+
+
+def test_match_rules_media_off_by_default(tmp_path):
+    (tmp_path / "logo.png").touch()
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+    matched = match_rules(DEFAULT_RULES, extensions, dirnames, filenames)
+    names = [r.name for r in matched]
+    assert not any("Media" in n for n in names)
+
+
+def test_match_rules_media_when_included(tmp_path):
+    (tmp_path / "logo.png").touch()
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+    all_rules = DEFAULT_RULES + MEDIA_RULES
+    matched = match_rules(all_rules, extensions, dirnames, filenames)
+    names = [r.name for r in matched]
+    assert any("Media" in n for n in names)
+
+
+def test_compute_new_patterns_skips_existing(tmp_path):
+    (tmp_path / "app.log").touch()
+    extensions, dirnames, filenames = scan_directory(tmp_path)
+    matched = match_rules(DEFAULT_RULES, extensions, dirnames, filenames)
+    existing_lines = ["*.log"]  # already present
+    new = compute_new_patterns(matched, existing_lines)
+    logs_patterns = new.get("Logs", [])
+    assert "*.log" not in logs_patterns   # shouldn't duplicate
+    assert "logs/" in logs_patterns       # but other log patterns still offered
+
+
+def test_find_already_tracked_matches(tmp_path):
+    make_git_repo(tmp_path)
+    (tmp_path / "app.log").touch()
+    (tmp_path / "main.py").touch()
+    git_commit_all(tmp_path)
+
+    new_by_category = {"Logs": ["*.log", "logs/"]}
+    tracked = git_ls_files(tmp_path)
+    warnings = find_already_tracked_matches(tracked, new_by_category)
+
+    matched_files = [f for f, _pattern in warnings]
+    assert "app.log" in matched_files
+    assert "main.py" not in matched_files
+
+
+def test_find_already_tracked_matches_empty_when_nothing_tracked_matches(tmp_path):
+    make_git_repo(tmp_path)
+    (tmp_path / "main.py").touch()
+    git_commit_all(tmp_path)
+
+    new_by_category = {"Logs": ["*.log", "logs/"]}
+    tracked = git_ls_files(tmp_path)
+    warnings = find_already_tracked_matches(tracked, new_by_category)
+    assert warnings == []
+
+
+# ---------- end-to-end tests (run the real CLI) ----------
+
+def test_end_to_end_dry_run_does_not_write(tmp_path, capsys):
+    (tmp_path / "app.log").touch()
+    main([str(tmp_path), "--dry-run"])
+    captured = capsys.readouterr()
+    assert "Logs" in captured.out
+    assert not (tmp_path / ".gitignore").exists()
+
+
+def test_end_to_end_yes_writes_gitignore(tmp_path):
+    (tmp_path / "app.log").touch()
+    main([str(tmp_path), "--yes"])
+    gitignore = tmp_path / ".gitignore"
+    assert gitignore.exists()
+    content = gitignore.read_text()
+    assert "*.log" in content
+
+
+def test_end_to_end_no_new_patterns_when_nothing_risky(tmp_path, capsys):
+    (tmp_path / "README.md").touch()
+    main([str(tmp_path), "--yes"])
+    captured = capsys.readouterr()
+    assert "Nothing new to add" in captured.out
+    assert not (tmp_path / ".gitignore").exists()
+
+
+def test_end_to_end_auto_untrack_removes_from_git_index(tmp_path):
+    make_git_repo(tmp_path)
+    (tmp_path / "app.log").touch()
+    (tmp_path / "main.py").touch()
+    git_commit_all(tmp_path)
+
+    main([str(tmp_path), "--yes", "--auto-untrack"])
+
+    tracked_after = git_ls_files(tmp_path)
+    assert "app.log" not in tracked_after
+    assert "main.py" in tracked_after
+    # file must still exist on disk — untracking is not deleting
+    assert (tmp_path / "app.log").exists()
+
+
+def test_end_to_end_media_skipped_unless_flag(tmp_path):
+    (tmp_path / "logo.png").touch()
+    main([str(tmp_path), "--yes"])
+    gitignore = tmp_path / ".gitignore"
+    # no risky non-media files -> nothing written at all
+    assert not gitignore.exists()
+
+
+def test_end_to_end_media_included_with_flag(tmp_path):
+    (tmp_path / "logo.png").touch()
+    main([str(tmp_path), "--yes", "--include-media"])
+    gitignore = tmp_path / ".gitignore"
+    assert gitignore.exists()
+    assert "*.png" in gitignore.read_text()
+
+
+def test_running_twice_does_not_duplicate_rules(tmp_path):
+    (tmp_path / "app.log").touch()
+    main([str(tmp_path), "--yes"])
+    first_content = (tmp_path / ".gitignore").read_text()
+
+    main([str(tmp_path), "--yes"])
+    second_content = (tmp_path / ".gitignore").read_text()
+
+    assert first_content == second_content  # nothing new to append second time