ghostnotes 1.0.0__tar.gz

ghostnotes-1.0.0/LICENSE

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

ghostnotes-1.0.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: ghostnotes
+Version: 1.0.0
+Summary: Strip personal annotations from code before committing
+Author-email: Tuna Akin <tuna.takin@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# GhostNotes
+**Version:** 1.0.0 | **Last Updated:** April 12, 2026
+
+A Git tool that strips tagged comments before committing.
+
+---
+
+## Installation
+
+```bash
+pip install ghostnotes
+```
+
+Then initialize in any git repo:
+
+```bash
+cd your-project
+ghostnotes init
+```
+
+---
+
+## What it does
+GhostNotes lets you leave personal notes in your code using a tag (default: `GN:`). Before every commit, it automatically strips them out so they never reach your repository.
+```python
+x = some_function() # GN: this breaks when input is negative, fix later
+```
+This comment line gets stripped before the commit so it looks like:
+```python
+x = some_function()
+```
+
+Your local file stays untouched.
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ghostnotes init` | Initialize GhostNotes in the current project |
+| `ghostnotes status` | Show all GhostNotes in the current project |
+| `ghostnotes set-tag --tag <tag>` | Change the default comment tag |
+| `ghostnotes add-lang --ext <.ext> --symb <symbol>` | Add support for a new language |
+| `ghostnotes pull` | Git pull that safely strips and re-applies your ghostnotes |

ghostnotes-1.0.0/README.md

@@ -0,0 +1,45 @@
+# GhostNotes
+**Version:** 1.0.0 | **Last Updated:** April 12, 2026
+
+A Git tool that strips tagged comments before committing.
+
+---
+
+## Installation
+
+```bash
+pip install ghostnotes
+```
+
+Then initialize in any git repo:
+
+```bash
+cd your-project
+ghostnotes init
+```
+
+---
+
+## What it does
+GhostNotes lets you leave personal notes in your code using a tag (default: `GN:`). Before every commit, it automatically strips them out so they never reach your repository.
+```python
+x = some_function() # GN: this breaks when input is negative, fix later
+```
+This comment line gets stripped before the commit so it looks like:
+```python
+x = some_function()
+```
+
+Your local file stays untouched.
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ghostnotes init` | Initialize GhostNotes in the current project |
+| `ghostnotes status` | Show all GhostNotes in the current project |
+| `ghostnotes set-tag --tag <tag>` | Change the default comment tag |
+| `ghostnotes add-lang --ext <.ext> --symb <symbol>` | Add support for a new language |
+| `ghostnotes pull` | Git pull that safely strips and re-applies your ghostnotes |

ghostnotes-1.0.0/ghostnotes/cli.py

@@ -0,0 +1,54 @@
+# CLI setup
+import argparse
+from ghostnotes.hook import install_hook, strip_ghostnotes
+from ghostnotes.config import create_config, update_exclude, set_tag, add_lang_support
+from ghostnotes.sync import pull, extract_notes
+
+def main():
+    parser = argparse.ArgumentParser(description="GhostNotes")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # init
+    init_parser = subparsers.add_parser("init", help="Initialize GhostNotes")
+
+    # set tag
+    tag_parser = subparsers.add_parser("set-tag", help="Set the tag for GhostNotes to ignore, Default tag is 'GN:'. ")
+    tag_parser.add_argument("--tag", required=True, help="New tag")
+
+    # add lang
+    lang_parser = subparsers.add_parser("add-lang", help="Add a new language support, Check .ghostnotes for the default languages supported")
+    lang_parser.add_argument("--ext", required=True, help="File extension (.py, .js, .sql etc.)")
+    lang_parser.add_argument("--symb", required=True, help="Symbol for commenting in the said language (# for .py, // for .java etc.)")
+
+    # pull
+    pull_parser = subparsers.add_parser("pull", help="Git pull with ghostnote-safe stripping and re-applying")
+
+    # status
+    status_parser = subparsers.add_parser("status", help="Show all ghost notes in the project")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        create_config()
+        update_exclude()
+        install_hook()
+        print("GhostNotes is successfully initialized.")
+    elif args.command == "set-tag":
+        set_tag(args.tag)
+    elif args.command == "add-lang":
+        add_lang_support(args.ext, args.symb)
+    elif args.command == "pull":
+        pull()
+    elif args.command == "status":
+        notes = extract_notes()
+        if not notes:
+            print("No ghost notes found.")
+        else:
+            total = sum(len(v) for v in notes.values())
+            print(f"Found {total} ghost note(s):\n")
+            for file, file_notes in notes.items():
+                for n in file_notes:
+                    print(f"  {file}:{n['line_number'] + 1}  — {n['note']}")
+
+if __name__ == "__main__":
+    main()

ghostnotes-1.0.0/ghostnotes/config.py

@@ -0,0 +1,74 @@
+# file for creating the .ghostnotes configuration
+import configparser
+import os
+
+def create_config():
+    if not os.path.isdir('.git'):
+        print("This project is not initialized with git. GhostNotes only works for directories already initialized with git.")
+        return
+
+    else:
+        # set-up the default config
+        config = configparser.ConfigParser()
+        config['settings'] = {'tag': 'GN:'}
+        config['languages'] = {'.py': '#', '.java': '//', '.js': '//', '.ts': '//'}
+
+        with open('.ghostnotes', 'w') as configfile:
+            config.write(configfile)
+
+        print("GhostNotes: Config file is created succesfully")
+
+def update_exclude():
+    loc = ".git/info/exclude"
+    
+    with open(loc, 'r') as file:
+        for line in file:
+            # already in exclude
+            if line.strip() == '.ghostnotes':
+                return
+            
+    file = open(loc, "a")
+    file.write('.ghostnotes\n')
+    file.close()
+        
+def load_config():
+    # check if config exists
+    if not os.path.isfile('.ghostnotes'):
+        print("This project is not initialized with GhostNotes.")
+        return
+    
+    else:
+        # set-up the default config
+        config = configparser.ConfigParser()
+        config.read('.ghostnotes')
+        print("GhostNotes: Config file is read succesfully")
+
+        return config
+
+# update tag 
+def set_tag(tag):
+    if not os.path.isfile('.ghostnotes'):
+        print("This project is not initialized with GhostNotes, cannot set new tag.")
+        return
+    
+    config = configparser.ConfigParser()
+    config.read('.ghostnotes')          # preserve existing settings
+    config['settings']['tag'] = tag
+    with open('.ghostnotes', 'w') as configfile:
+        config.write(configfile)
+
+    print(f"GhostNotes: Config file tag is set to {tag} succesfully")
+
+# add custom language comment support
+def add_lang_support(extension, notation):
+    if not os.path.isfile('.ghostnotes'):
+        print("This project is not initialized with GhostNotes, cannot add new file support.")
+        return
+    
+    config = configparser.ConfigParser()
+    config.read('.ghostnotes')
+    config['languages'][extension] = notation
+    with open('.ghostnotes', 'w') as configfile:
+        config.write(configfile)
+
+    print(f"GhostNotes: Config file language support for {extension} files are added with symbol {notation} successfuly.")

ghostnotes-1.0.0/ghostnotes/hook.py

@@ -0,0 +1,103 @@
+import os
+import stat
+import subprocess
+from pathlib import Path 
+from ghostnotes.config import load_config
+
+# for adding this script to pre-commit
+def install_hook():
+    path = '.git/hooks/pre-commit'
+    command = 'python3 -m ghostnotes.hook'
+
+    # if a pre-commit hook file already exists:
+    if os.path.exists(path):
+        with open(path, 'r') as file:
+            for line in file:
+                if line.strip() == command:
+                    return
+            
+        with open(path, 'a') as file:
+            file.write(f'\n{command}\n')
+    else:
+        with open(path, 'w') as file:
+            file.write(f'#!/bin/bash\n{command}\n')
+
+    # make the file executable
+    os.chmod(path, os.stat(path).st_mode | stat.S_IEXEC)
+
+# main logic function for stripping the committed files of the keyworded comments
+def strip_ghostnotes():
+    """
+    Read Config
+    Get the list of staged files — how do you ask git which files are staged? Think about what terminal command you'd run manually.
+    Filter to only supported extensions
+    For each supported file, strip lines matching the tag.
+    Re-stage the files with git add
+    """
+    # read config
+    configuration = load_config()
+
+    if configuration is None:
+        print("Ghostnotes is not configured.")
+        return
+
+    # get the list of staged file:
+    res = subprocess.run(['git', 'diff', '--name-only', '--cached'], capture_output=True, text=True)
+    staged_files = res.stdout.splitlines()
+    supported_staged_files = list()
+
+    # filter staged_files to only supported file types
+    for f in staged_files:
+        if Path(f).suffix in configuration['languages']:
+            supported_staged_files.append(f)
+
+    # strip lines matching the tag
+    for file in supported_staged_files:
+        # check the commenting style for the file type from configuration['languages'] as well as the tag from configuration['settings'] to build the exact sequence of chars we are looking for
+        comment = configuration['languages'][Path(file).suffix]
+        tag = configuration['settings']['tag']
+        pattern = comment + ' ' + tag
+
+        # read the staged version from the git index, not the working tree
+        staged_content = subprocess.run(
+            ['git', 'show', f':{file}'],
+            capture_output=True, text=True
+        ).stdout
+
+        new_lines = list()
+        for line in staged_content.splitlines(keepends=True):
+            # strip only if the pattern is not inside a string literal
+            if pattern in line:
+                idx = line.index(pattern)
+                prefix = line[:idx]
+                # if an odd number of quotes precede the pattern, it's inside a string
+                in_string = (prefix.count('"') % 2 == 1) or (prefix.count("'") % 2 == 1)
+                if not in_string:
+                    line = line[:idx].rstrip() + '\n'
+            new_lines.append(line)
+
+        stripped_content = ''.join(new_lines)
+
+        # write the stripped content back into the git index only
+        hash_result = subprocess.run(
+            ['git', 'hash-object', '-w', '--stdin'],
+            input=stripped_content, capture_output=True, text=True
+        )
+        blob_hash = hash_result.stdout.strip()
+
+        # get the file's mode from the index
+        ls_result = subprocess.run(
+            ['git', 'ls-files', '--stage', file],
+            capture_output=True, text=True
+        )
+        if not ls_result.stdout.strip():
+            continue
+        mode = ls_result.stdout.split()[0]
+
+        # update the index entry with the new blob
+        subprocess.run(
+            ['git', 'update-index', '--cacheinfo', f'{mode},{blob_hash},{file}']
+        )
+
+if __name__ == "__main__":
+    strip_ghostnotes()

ghostnotes-1.0.0/ghostnotes/sync.py

@@ -0,0 +1,140 @@
+import subprocess
+from pathlib import Path
+from ghostnotes.config import load_config
+
+
+def extract_notes():
+    config = load_config()
+    notes = {}
+
+    for file in Path('.').rglob('*'):
+        # skip hidden directories (.git, .venv, etc.)
+        if any(part.startswith('.') for part in file.parts):
+            continue
+
+        if not file.is_file():
+            continue
+
+        ext = file.suffix
+        if ext not in config['languages']:
+            continue
+
+        comment = config['languages'][ext]
+        tag = config['settings']['tag']
+        pattern = comment + ' ' + tag
+
+        # extract notes, store code without comment, store comment, and store line num
+        file_notes = []
+        try:
+            with open(file, 'r') as f:
+                for i, line in enumerate(f):
+                    if pattern in line:
+                        stripped = line.split(pattern)[0].rstrip()
+                        note_text = line.split(pattern, 1)[1].strip()
+                        file_notes.append({
+                            'stripped_line': stripped,
+                            'note': note_text,
+                            'line_number': i,
+                        })
+        except UnicodeDecodeError:
+            continue
+
+        if file_notes:
+            notes[str(file)] = file_notes
+
+    return notes
+
+def strip_working_tree(notes):
+    for file, file_notes in notes.items():
+        patterns = {n['line_number'] for n in file_notes}
+
+        with open(file, 'r') as f:
+            lines = f.readlines()
+
+        for line_num in patterns:
+            note_entry = next(n for n in file_notes if n['line_number'] == line_num)
+            lines[line_num] = note_entry['stripped_line'] + '\n'
+
+        with open(file, 'w') as f:
+            f.writelines(lines)
+
+
+def reapply_notes(notes, config):
+    for file, file_notes in notes.items():
+        if not Path(file).is_file():
+            for n in file_notes:
+                print(f"  ORPHANED (file deleted): {file} — {n['note']}")
+            continue
+
+        comment = config['languages'][Path(file).suffix]
+        tag = config['settings']['tag']
+        pattern = comment + ' ' + tag
+
+        with open(file, 'r') as f:
+            lines = f.readlines()
+
+        orphaned = []
+
+        for n in file_notes:
+            target = n['stripped_line']
+            line_num = n['line_number']
+            matched = False
+
+            # 1. exact match at same line number
+            if line_num < len(lines) and lines[line_num].rstrip() == target:
+                lines[line_num] = target + ' ' + pattern + ' ' + n['note'] + '\n'
+                matched = True
+
+            # 2. exact match nearby (within 20 lines)
+            if not matched:
+                start = max(0, line_num - 20)
+                end = min(len(lines), line_num + 20)
+                for i in range(start, end):
+                    if lines[i].rstrip() == target:
+                        lines[i] = target + ' ' + pattern + ' ' + n['note'] + '\n'
+                        matched = True
+                        break
+
+            # 3. exact match anywhere in file
+            if not matched:
+                for i in range(len(lines)):
+                    if lines[i].rstrip() == target:
+                        lines[i] = target + ' ' + pattern + ' ' + n['note'] + '\n'
+                        matched = True
+                        break
+
+            # 4. orphaned
+            if not matched:
+                orphaned.append(n)
+
+        with open(file, 'w') as f:
+            f.writelines(lines)
+
+        for n in orphaned:
+            print(f"  ORPHANED: {file}:{n['line_number']} — {n['note']}")
+
+
+def pull():
+    config = load_config()
+    notes = extract_notes()
+
+    if notes:
+        print(f"GhostNotes: Saved {sum(len(v) for v in notes.values())} note(s), stripping before pull...")
+        strip_working_tree(notes)
+
+    result = subprocess.run(['git', 'pull'], capture_output=True, text=True)
+    print(result.stdout)
+    if result.stderr:
+        print(result.stderr)
+
+    if notes:
+        if result.returncode != 0:
+            print("GhostNotes: Pull failed, restoring notes to working tree...")
+            reapply_notes(notes, config)
+            print("GhostNotes: Notes restored. Resolve the pull issue and try again.")
+        else:
+            print("GhostNotes: Re-applying notes...")
+            reapply_notes(notes, config)
+            print("GhostNotes: Done.")
+
+    return result.returncode

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

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: ghostnotes
+Version: 1.0.0
+Summary: Strip personal annotations from code before committing
+Author-email: Tuna Akin <tuna.takin@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# GhostNotes
+**Version:** 1.0.0 | **Last Updated:** April 12, 2026
+
+A Git tool that strips tagged comments before committing.
+
+---
+
+## Installation
+
+```bash
+pip install ghostnotes
+```
+
+Then initialize in any git repo:
+
+```bash
+cd your-project
+ghostnotes init
+```
+
+---
+
+## What it does
+GhostNotes lets you leave personal notes in your code using a tag (default: `GN:`). Before every commit, it automatically strips them out so they never reach your repository.
+```python
+x = some_function() # GN: this breaks when input is negative, fix later
+```
+This comment line gets stripped before the commit so it looks like:
+```python
+x = some_function()
+```
+
+Your local file stays untouched.
+
+---
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ghostnotes init` | Initialize GhostNotes in the current project |
+| `ghostnotes status` | Show all GhostNotes in the current project |
+| `ghostnotes set-tag --tag <tag>` | Change the default comment tag |
+| `ghostnotes add-lang --ext <.ext> --symb <symbol>` | Add support for a new language |
+| `ghostnotes pull` | Git pull that safely strips and re-applies your ghostnotes |

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

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+ghostnotes/__init__.py
+ghostnotes/cli.py
+ghostnotes/config.py
+ghostnotes/hook.py
+ghostnotes/sync.py
+ghostnotes.egg-info/PKG-INFO
+ghostnotes.egg-info/SOURCES.txt
+ghostnotes.egg-info/dependency_links.txt
+ghostnotes.egg-info/entry_points.txt
+ghostnotes.egg-info/top_level.txt
+tests/test_config.py
+tests/test_hook.py
+tests/test_sync.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+ghostnotes

ghostnotes-1.0.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ghostnotes"
+version = "1.0.0"
+description = "Strip personal annotations from code before committing"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    {name = "Tuna Akin", email = "tuna.takin@gmail.com"}
+]
+readme = "README.md"
+
+[project.scripts]
+ghostnotes = "ghostnotes.cli:main"

ghostnotes-1.0.0/setup.cfg

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

ghostnotes-1.0.0/tests/test_config.py

@@ -0,0 +1,222 @@
+import os
+import tempfile
+import configparser
+
+from ghostnotes.config import (
+    create_config,
+    load_config,
+    set_tag,
+    add_lang_support,
+    update_exclude,
+)
+
+
+# --- Helper ---
+# set up a fake project folder so we don't touch real files.
+def make_fake_git_dir():
+    tmp = tempfile.mkdtemp()
+    os.makedirs(os.path.join(tmp, ".git", "info"))
+    with open(os.path.join(tmp, ".git", "info", "exclude"), "w") as f:
+        f.write("")
+    return tmp
+
+
+def test_create_config_makes_file():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    # check: the file should now exist
+    assert os.path.isfile(".ghostnotes")
+
+    # go back and remove temp dir
+    os.chdir(original_dir)
+
+
+def test_create_config_has_default_tag():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    # read the file and check the tag value
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+    assert config["settings"]["tag"] == "GN:"
+
+    os.chdir(original_dir)
+
+
+def test_create_config_has_default_languages():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+    assert config["languages"][".py"] == "#"
+    assert config["languages"][".java"] == "//"
+    assert config["languages"][".js"] == "//"
+    assert config["languages"][".ts"] == "//"
+
+    os.chdir(original_dir)
+
+
+def test_create_config_refuses_without_git():
+    tmp = tempfile.mkdtemp()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    # .ghostnotes should not exist because there's no git
+    assert not os.path.isfile(".ghostnotes")
+
+    os.chdir(original_dir)
+
+def test_load_config_returns_config():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config() 
+    config = load_config() 
+    assert config is not None
+    assert config["settings"]["tag"] == "GN:"
+
+    os.chdir(original_dir)
+
+
+def test_load_config_returns_none_without_file():
+    tmp = tempfile.mkdtemp()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    result = load_config()
+
+    assert result is None
+
+    os.chdir(original_dir)
+
+def test_set_tag_changes_tag():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    set_tag("TODO:")
+
+    # read the file again and check the tag changed
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+    assert config["settings"]["tag"] == "TODO:"
+
+    os.chdir(original_dir)
+
+
+def test_set_tag_keeps_languages():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    set_tag("NOTE:")
+
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+
+    assert ".py" in config["languages"]
+    assert ".js" in config["languages"]
+
+    os.chdir(original_dir)
+
+
+def test_set_tag_refuses_without_config():
+    tmp = tempfile.mkdtemp()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    set_tag("NEW:")
+
+    # .ghostnotes should still not exist
+    assert not os.path.isfile(".ghostnotes")
+
+    os.chdir(original_dir)
+
+
+def test_add_lang_support_adds_language():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    add_lang_support(".rb", "#")
+
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+    assert config["languages"][".rb"] == "#"
+
+    os.chdir(original_dir)
+
+
+def test_add_lang_support_keeps_existing():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    add_lang_support(".go", "//")
+
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+    assert config["languages"][".py"] == "#"
+    assert config["languages"][".go"] == "//"
+
+    os.chdir(original_dir)
+
+
+def test_add_lang_support_refuses_without_config():
+    tmp = tempfile.mkdtemp()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    add_lang_support(".rb", "#")
+
+    assert not os.path.isfile(".ghostnotes")
+
+    os.chdir(original_dir)
+
+def test_update_exclude_adds_entry():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    update_exclude()
+
+    with open(".git/info/exclude", "r") as f:
+        contents = f.read()
+    assert ".ghostnotes" in contents
+
+    os.chdir(original_dir)
+
+
+def test_update_exclude_no_duplicates():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    update_exclude()
+    update_exclude()
+
+    with open(".git/info/exclude", "r") as f:
+        lines = f.readlines()
+
+    count = sum(1 for line in lines if line.strip() == ".ghostnotes")
+    assert count == 1
+
+    os.chdir(original_dir)

ghostnotes-1.0.0/tests/test_hook.py

@@ -0,0 +1,228 @@
+import os
+import stat
+import tempfile
+import subprocess
+from ghostnotes.hook import install_hook, strip_ghostnotes
+from ghostnotes.config import create_config
+
+
+# --- Helpers ---
+def make_fake_git_dir():
+    tmp = tempfile.mkdtemp()
+    os.makedirs(os.path.join(tmp, ".git", "hooks"))
+    os.makedirs(os.path.join(tmp, ".git", "info"))
+    with open(os.path.join(tmp, ".git", "info", "exclude"), "w") as f:
+        f.write("")
+    return tmp
+def make_real_git_repo():
+    tmp = tempfile.mkdtemp()
+    subprocess.run(["git", "init", tmp], capture_output=True)
+    subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=tmp, capture_output=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp, capture_output=True)
+    return tmp
+
+def test_install_hook_creates_file():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    install_hook()
+
+    assert os.path.isfile(".git/hooks/pre-commit")
+
+    os.chdir(original_dir)
+
+
+def test_install_hook_has_shebang():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    install_hook()
+
+    with open(".git/hooks/pre-commit", "r") as f:
+        first_line = f.readline().strip()
+    assert first_line == "#!/bin/bash"
+
+    os.chdir(original_dir)
+
+
+def test_install_hook_has_command():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    install_hook()
+
+    with open(".git/hooks/pre-commit", "r") as f:
+        contents = f.read()
+    assert "python3 -m ghostnotes.hook" in contents
+
+    os.chdir(original_dir)
+
+
+def test_install_hook_is_executable():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    install_hook()
+
+    file_stat = os.stat(".git/hooks/pre-commit")
+    assert file_stat.st_mode & stat.S_IEXEC
+
+    os.chdir(original_dir)
+
+
+def test_install_hook_appends_to_existing(): # crucial to not mess up user's previous hooks and workflows
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    # create an existing pre-commit hook with some other command
+    with open(".git/hooks/pre-commit", "w") as f:
+        f.write("#!/bin/bash\necho 'existing hook'\n")
+
+    install_hook()
+
+    with open(".git/hooks/pre-commit", "r") as f:
+        contents = f.read()
+
+    # both the old content and the new command should be there
+    assert "existing hook" in contents
+    assert "python3 -m ghostnotes.hook" in contents
+
+    os.chdir(original_dir)
+
+
+def test_install_hook_no_duplicate():
+    tmp = make_fake_git_dir()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    install_hook()
+    install_hook()
+
+    with open(".git/hooks/pre-commit", "r") as f:
+        contents = f.read()
+
+    count = contents.count("python3 -m ghostnotes.hook")
+    assert count == 1
+
+    os.chdir(original_dir)
+
+
+# these tests use a real git repo because strip_ghostnotes()
+# runs actual git commands (git diff, git show, git hash-object, etc.)
+
+def test_strip_removes_ghost_note_from_index(): # crucial
+    tmp = make_real_git_repo()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    # create a python file with a ghost note comment
+    with open("example.py", "w") as f:
+        f.write("x = 1\n")
+        f.write("y = 2  # GN: this is a ghost note\n")
+        f.write("z = 3\n")
+
+    # stage the file (add it to the git index)
+    subprocess.run(["git", "add", "example.py"], capture_output=True)
+
+    strip_ghostnotes()
+
+    # read what's now in the git index (staged version) after stripping
+    result = subprocess.run(
+        ["git", "show", ":example.py"],
+        capture_output=True, text=True
+    )
+    staged_content = result.stdout
+
+    assert "GN:" not in staged_content
+    assert "y = 2" in staged_content
+    assert "x = 1" in staged_content
+    assert "z = 3" in staged_content
+
+    os.chdir(original_dir)
+
+
+def test_strip_leaves_non_tagged_comments(): # crucial
+    tmp = make_real_git_repo()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("# this is a normal comment\n")
+        f.write("x = 1  # GN: ghost note to remove\n")
+        f.write("y = 2  # regular inline comment\n")
+
+    subprocess.run(["git", "add", "example.py"], capture_output=True)
+
+    strip_ghostnotes()
+
+    result = subprocess.run(
+        ["git", "show", ":example.py"],
+        capture_output=True, text=True
+    )
+    staged_content = result.stdout
+
+    assert "# this is a normal comment" in staged_content
+    assert "# regular inline comment" in staged_content
+    assert "GN:" not in staged_content
+
+    os.chdir(original_dir)
+
+
+def test_strip_ignores_unsupported_files():
+    tmp = make_real_git_repo()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("notes.txt", "w") as f:
+        f.write("some text # GN: this should stay\n")
+
+    subprocess.run(["git", "add", "notes.txt"], capture_output=True)
+
+    strip_ghostnotes()
+
+    result = subprocess.run(
+        ["git", "show", ":notes.txt"],
+        capture_output=True, text=True
+    )
+
+    assert "# GN: this should stay" in result.stdout
+
+    os.chdir(original_dir)
+
+
+def test_strip_works_with_js_files():
+    tmp = make_real_git_repo()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("app.js", "w") as f:
+        f.write("const x = 1;\n")
+        f.write("const y = 2; // GN: remember to refactor\n")
+
+    subprocess.run(["git", "add", "app.js"], capture_output=True)
+
+    strip_ghostnotes()
+
+    result = subprocess.run(
+        ["git", "show", ":app.js"],
+        capture_output=True, text=True
+    )
+    staged_content = result.stdout
+
+    assert "GN:" not in staged_content
+    assert "const y = 2;" in staged_content
+
+    os.chdir(original_dir)

ghostnotes-1.0.0/tests/test_sync.py

@@ -0,0 +1,282 @@
+import os
+import tempfile
+import configparser
+
+from ghostnotes.config import create_config
+from ghostnotes.sync import extract_notes, strip_working_tree, reapply_notes
+
+
+# --- Helper ---
+def make_project():
+    tmp = tempfile.mkdtemp()
+    os.makedirs(os.path.join(tmp, ".git", "info"))
+    with open(os.path.join(tmp, ".git", "info", "exclude"), "w") as f:
+        f.write("")
+    return tmp
+
+def test_extract_notes_finds_ghost_note():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("x = 1\n")
+        f.write("y = 2  # GN: remember this\n")
+
+    notes = extract_notes()
+
+    assert "example.py" in notes
+    assert len(notes["example.py"]) == 1
+    assert notes["example.py"][0]["note"] == "remember this"
+
+    os.chdir(original_dir)
+
+
+def test_extract_notes_gets_line_number():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("x = 1\n")       # line 0
+        f.write("y = 2\n")       # line 1
+        f.write("z = 3  # GN: note on line 2\n")  # line 2
+
+    notes = extract_notes()
+
+    assert notes["example.py"][0]["line_number"] == 2
+
+    os.chdir(original_dir)
+
+
+def test_extract_notes_gets_stripped_line():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+
+    notes = extract_notes()
+
+    assert notes["example.py"][0]["stripped_line"] == "x = 1"
+
+    os.chdir(original_dir)
+
+
+def test_extract_notes_ignores_unsupported_files():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("notes.txt", "w") as f:
+        f.write("hello # GN: should be ignored\n")
+
+    notes = extract_notes()
+
+    assert "notes.txt" not in notes
+
+    os.chdir(original_dir)
+
+
+def test_extract_notes_skips_hidden_dirs():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open(os.path.join(".git", "test.py"), "w") as f:
+        f.write("x = 1  # GN: hidden note\n")
+
+    notes = extract_notes()
+
+    assert len(notes) == 0
+
+    os.chdir(original_dir)
+
+
+def test_extract_notes_finds_multiple_notes():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: first note\n")
+        f.write("y = 2\n")
+        f.write("z = 3  # GN: second note\n")
+
+    notes = extract_notes()
+
+    assert len(notes["example.py"]) == 2
+
+    os.chdir(original_dir)
+
+
+def test_strip_working_tree_removes_notes():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+        f.write("y = 2\n")
+
+    notes = extract_notes()
+    strip_working_tree(notes)
+
+    with open("example.py", "r") as f:
+        content = f.read()
+
+    assert "GN:" not in content
+    assert "x = 1\n" in content
+    assert "y = 2\n" in content
+
+    os.chdir(original_dir)
+
+
+def test_strip_working_tree_keeps_other_lines():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+
+    with open("example.py", "w") as f:
+        f.write("# a normal comment\n")
+        f.write("x = 1  # GN: remove me\n")
+        f.write("y = 2  # regular comment\n")
+
+    notes = extract_notes()
+    strip_working_tree(notes)
+
+    with open("example.py", "r") as f:
+        content = f.read()
+
+    assert "# a normal comment" in content
+    assert "# regular comment" in content
+    assert "GN:" not in content
+
+    os.chdir(original_dir)
+
+
+def test_reapply_notes_restores_notes():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+        f.write("y = 2\n")
+
+    notes = extract_notes()
+    strip_working_tree(notes)
+    reapply_notes(notes, config)
+
+    with open("example.py", "r") as f:
+        content = f.read()
+
+    # the note should be back
+    assert "# GN: my note" in content
+    assert "x = 1" in content
+
+    os.chdir(original_dir)
+
+
+def test_reapply_notes_handles_shifted_lines():
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+
+    notes = extract_notes()
+    strip_working_tree(notes)
+
+    with open("example.py", "r") as f:
+        lines = f.readlines()
+    lines.insert(0, "# new line from pull\n")
+    with open("example.py", "w") as f:
+        f.writelines(lines)
+
+    reapply_notes(notes, config)
+
+    with open("example.py", "r") as f:
+        content = f.read()
+
+    assert "# GN: my note" in content
+
+    os.chdir(original_dir)
+
+
+def test_reapply_notes_reports_orphaned(capsys):
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+
+    notes = extract_notes()
+
+    with open("example.py", "w") as f:
+        f.write("totally_different = True\n")
+
+    reapply_notes(notes, config)
+
+    captured = capsys.readouterr()
+    assert "ORPHANED" in captured.out
+
+    os.chdir(original_dir)
+
+
+def test_reapply_notes_reports_deleted_file(capsys):
+    """Does reapply_notes() print ORPHANED when the file was deleted?"""
+    tmp = make_project()
+    original_dir = os.getcwd()
+    os.chdir(tmp)
+
+    create_config()
+    config = configparser.ConfigParser()
+    config.read(".ghostnotes")
+
+    with open("example.py", "w") as f:
+        f.write("x = 1  # GN: my note\n")
+
+    notes = extract_notes()
+
+    # delete the file entirely
+    os.remove("example.py")
+
+    reapply_notes(notes, config)
+
+    captured = capsys.readouterr()
+    assert "ORPHANED" in captured.out
+    assert "file deleted" in captured.out
+
+    os.chdir(original_dir)