hard-lint-py 0.0.0__tar.gz

hard_lint_py-0.0.0/PKG-INFO

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: hard-lint-py
+Version: 0.0.0
+Summary: Rigorous linting and code quality setup for Python projects with pre-commit hooks
+License: MIT
+Keywords: linting,pre-commit,code-quality,ruff,black,isort,coverage
+Author: Naylson Ferreira
+Author-email: naylsonfsa@gmail.com
+Requires-Python: >=3.10
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: black (>=23.0.0)
+Requires-Dist: isort (>=5.12.0)
+Requires-Dist: pre-commit (>=3.0.0)
+Requires-Dist: ruff (>=0.1.0)
+Project-URL: Homepage, https://github.com/naylsonferreira/hard-lint-py
+Project-URL: Issues, https://github.com/naylsonferreira/hard-lint-py/issues
+Project-URL: Repository, https://github.com/naylsonferreira/hard-lint-py.git
+Description-Content-Type: text/markdown
+
+# Hard-Lint for Python 🐍
+
+Rigorous linting and code quality setup for Python projects with automatic pre-commit hooks.
+
+## Features
+
+- **Automated Pre-commit Hooks**: Validates code before every commit
+  - `pre-commit`: Runs `ruff`, `black`, and `isort`
+  - `commit-msg`: Validates messages follow Conventional Commits format
+- **Strict Linting**: Ruff checks for errors, complexity, and code quality
+- **Synchronized Formatters**: Ruff, Black, and isort configured with same profile (no conflicts)
+- **Zero Configuration**: Works out-of-the-box with sensible defaults
+- **Multiplattform**: Works on Windows, macOS, and Linux
+- **Auto-setup**: Single command to enable all checks
+
+## Installation
+
+```bash
+pip install hard-lint-py
+# or with poetry
+poetry add -D hard-lint-py
+```
+
+## Quick Start
+
+```bash
+# 1. Install and setup hooks
+hard-lint-py
+
+# 2. Make your first commit
+git add .
+git commit -m "feat: initial setup"
+```
+
+That's it! Your project now has:
+- **Ruff** for fast Python linting
+- **Black** for code formatting
+- **isort** for import sorting
+- **Commitlint** for commit message validation
+
+## What Gets Installed
+
+### Git Hooks
+
+Hooks are created in `.hardlint/_/`:
+
+- **pre-commit**: Runs before commits to validate code
+  - Fixes issues with `ruff check --fix`
+  - Formats with `black`
+  - Sorts imports with `isort`
+  - Validates no comments exist
+
+- **commit-msg**: Validates commit messages
+  - Must follow Conventional Commits format
+  - Examples: `feat:`, `fix:`, `chore:`, `docs:`, etc.
+
+## Linting Rules
+
+### Ruff Rules Enforced
+
+| Rule | Category | Description |
+|------|----------|-----------|
+| E | pycodestyle errors | PEP 8 compliance |
+| F | Pyflakes | Unused imports, undefined names |
+| W | pycodestyle warnings | Code warnings |
+| I | isort | Import sorting |
+| N | pep8-naming | Naming conventions |
+| C | mccabe | Code complexity |
+| B | flake8-bugbear | Common bugs and design problems |
+| RUF | Ruff-specific | Additional quality checks |
+| UP | pyupgrade | Modernize Python syntax |
+
+### Synchronized Formatter Configuration
+
+All three formatters (Ruff, Black, isort) use the **same profile** to prevent conflicts:
+
+| Aspect | Configuration | Notes |
+|--------|---------------|-------|
+| **Line Length** | 100 characters | Consistent across all tools |
+| **Python Version** | 3.10+ | Targets modern Python |
+| **Imports Profile** | `isort: black` | Compatible with Black |
+| **Trailing Commas** | Enabled | Multi-line consistency |
+
+### Configuration
+
+Auto-configured in `pyproject.toml`:
+
+```toml
+[tool.black]
+line-length = 100
+target-version = ["py310", "py311", "py312"]
+
+[tool.isort]
+profile = "black"           # Compatible with Black
+line_length = 100
+known_first_party = ["hard_lint_py"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "W", "I", "N", "C", "B", "RUF", "UP"]
+```
+
+## Usage
+
+### Normal workflow
+
+```bash
+# Make changes
+cat > new_file.py << 'EOF'
+def greet(name):
+    # Greet a person by name
+    return f"Hello, {name}!"
+EOF
+
+# Stage changes
+git add new_file.py
+
+# Commit (hooks will run automatically)
+git commit -m "feat: add greeting function"
+```
+
+### Pre-commit Hook Behavior
+
+When you commit, the hook automatically:
+1. **Ruff**: Checks for linting issues, imports, and code quality
+2. **Black**: Formats code to 100-character lines
+3. **isort**: Sorts and organizes imports
+4. Blocks commit if any issues can't be auto-fixed
+
+If pre-commit fails:
+```bash
+# Fix will be auto-applied, just re-add and commit
+git add .
+git commit -m "feat: your message"
+```
+
+### If commit-msg fails
+
+Invalid message example:
+```bash
+git commit -m "added this feature"  # ❌ Missing type prefix
+```
+
+Valid message example:
+```bash
+git commit -m "feat: added new feature"  # ✅ Has type prefix
+```
+
+### Skip hooks (use with caution)
+
+```bash
+git commit -m "..." --no-verify
+```
+
+## Configuration
+
+All tools read from `pyproject.toml`. Customize as needed:
+
+```toml
+[tool.ruff]
+line-length = 120
+select = ["E", "F", "W"]
+
+[tool.black]
+line-length = 120
+
+[tool.isort]
+profile = "black"
+line_length = 120
+```
+
+## Troubleshooting
+
+**Hooks not running?**
+```bash
+# Re-run installation
+hard-lint-py
+```
+
+
+
+**Commit-msg validation failing?**
+- Check that your message starts with a type: `feat:`, `fix:`, `chore:`, etc.
+
+**Formatters conflicting with each other?**
+- They shouldn't! Ruff, Black, and isort are configured with the same profile
+- If you see conflicts, run all three: `ruff check --fix`, `black .`, `isort .`
+
+**Line length conflicts?**
+- All tools configured to 100 characters
+- Black and isort won't fight over formatting
+- Ruff respects Black's decisions (E501 ignored)
+
+## Supported Python Versions
+
+- Python 3.10+
+- Python 3.11
+- Python 3.12
+
+## Development
+
+When developing with hard-lint-py:
+
+### Pre-commit Validation
+Your code will be validated on every commit:
+```bash
+git commit -m "feat: your feature"
+# Runs: ruff check --fix → black → isort → commitlint
+```
+
+### Manual Validation
+Run validation checks manually:
+```bash
+# All checks
+make lint
+make format
+make test
+make test-cov
+
+# Individual tools
+poetry run ruff check src/ tests/
+poetry run black --check src/ tests/
+poetry run isort --check-only src/ tests/
+```
+
+### Quality Standards
+- ✅ 99% code coverage
+- ✅ No unused imports or variables
+- ✅ Consistent formatting (100 char lines)
+- ✅ Code complexity within limits
+- ✅ Modern Python syntax
+- ✅ No common bugs or design problems
+
+## License
+
+MIT
+
+## Author
+
+Naylson Ferreira
+

hard_lint_py-0.0.0/README.md

@@ -0,0 +1,241 @@
+# Hard-Lint for Python 🐍
+
+Rigorous linting and code quality setup for Python projects with automatic pre-commit hooks.
+
+## Features
+
+- **Automated Pre-commit Hooks**: Validates code before every commit
+  - `pre-commit`: Runs `ruff`, `black`, and `isort`
+  - `commit-msg`: Validates messages follow Conventional Commits format
+- **Strict Linting**: Ruff checks for errors, complexity, and code quality
+- **Synchronized Formatters**: Ruff, Black, and isort configured with same profile (no conflicts)
+- **Zero Configuration**: Works out-of-the-box with sensible defaults
+- **Multiplattform**: Works on Windows, macOS, and Linux
+- **Auto-setup**: Single command to enable all checks
+
+## Installation
+
+```bash
+pip install hard-lint-py
+# or with poetry
+poetry add -D hard-lint-py
+```
+
+## Quick Start
+
+```bash
+# 1. Install and setup hooks
+hard-lint-py
+
+# 2. Make your first commit
+git add .
+git commit -m "feat: initial setup"
+```
+
+That's it! Your project now has:
+- **Ruff** for fast Python linting
+- **Black** for code formatting
+- **isort** for import sorting
+- **Commitlint** for commit message validation
+
+## What Gets Installed
+
+### Git Hooks
+
+Hooks are created in `.hardlint/_/`:
+
+- **pre-commit**: Runs before commits to validate code
+  - Fixes issues with `ruff check --fix`
+  - Formats with `black`
+  - Sorts imports with `isort`
+  - Validates no comments exist
+
+- **commit-msg**: Validates commit messages
+  - Must follow Conventional Commits format
+  - Examples: `feat:`, `fix:`, `chore:`, `docs:`, etc.
+
+## Linting Rules
+
+### Ruff Rules Enforced
+
+| Rule | Category | Description |
+|------|----------|-----------|
+| E | pycodestyle errors | PEP 8 compliance |
+| F | Pyflakes | Unused imports, undefined names |
+| W | pycodestyle warnings | Code warnings |
+| I | isort | Import sorting |
+| N | pep8-naming | Naming conventions |
+| C | mccabe | Code complexity |
+| B | flake8-bugbear | Common bugs and design problems |
+| RUF | Ruff-specific | Additional quality checks |
+| UP | pyupgrade | Modernize Python syntax |
+
+### Synchronized Formatter Configuration
+
+All three formatters (Ruff, Black, isort) use the **same profile** to prevent conflicts:
+
+| Aspect | Configuration | Notes |
+|--------|---------------|-------|
+| **Line Length** | 100 characters | Consistent across all tools |
+| **Python Version** | 3.10+ | Targets modern Python |
+| **Imports Profile** | `isort: black` | Compatible with Black |
+| **Trailing Commas** | Enabled | Multi-line consistency |
+
+### Configuration
+
+Auto-configured in `pyproject.toml`:
+
+```toml
+[tool.black]
+line-length = 100
+target-version = ["py310", "py311", "py312"]
+
+[tool.isort]
+profile = "black"           # Compatible with Black
+line_length = 100
+known_first_party = ["hard_lint_py"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = ["E", "F", "W", "I", "N", "C", "B", "RUF", "UP"]
+```
+
+## Usage
+
+### Normal workflow
+
+```bash
+# Make changes
+cat > new_file.py << 'EOF'
+def greet(name):
+    # Greet a person by name
+    return f"Hello, {name}!"
+EOF
+
+# Stage changes
+git add new_file.py
+
+# Commit (hooks will run automatically)
+git commit -m "feat: add greeting function"
+```
+
+### Pre-commit Hook Behavior
+
+When you commit, the hook automatically:
+1. **Ruff**: Checks for linting issues, imports, and code quality
+2. **Black**: Formats code to 100-character lines
+3. **isort**: Sorts and organizes imports
+4. Blocks commit if any issues can't be auto-fixed
+
+If pre-commit fails:
+```bash
+# Fix will be auto-applied, just re-add and commit
+git add .
+git commit -m "feat: your message"
+```
+
+### If commit-msg fails
+
+Invalid message example:
+```bash
+git commit -m "added this feature"  # ❌ Missing type prefix
+```
+
+Valid message example:
+```bash
+git commit -m "feat: added new feature"  # ✅ Has type prefix
+```
+
+### Skip hooks (use with caution)
+
+```bash
+git commit -m "..." --no-verify
+```
+
+## Configuration
+
+All tools read from `pyproject.toml`. Customize as needed:
+
+```toml
+[tool.ruff]
+line-length = 120
+select = ["E", "F", "W"]
+
+[tool.black]
+line-length = 120
+
+[tool.isort]
+profile = "black"
+line_length = 120
+```
+
+## Troubleshooting
+
+**Hooks not running?**
+```bash
+# Re-run installation
+hard-lint-py
+```
+
+
+
+**Commit-msg validation failing?**
+- Check that your message starts with a type: `feat:`, `fix:`, `chore:`, etc.
+
+**Formatters conflicting with each other?**
+- They shouldn't! Ruff, Black, and isort are configured with the same profile
+- If you see conflicts, run all three: `ruff check --fix`, `black .`, `isort .`
+
+**Line length conflicts?**
+- All tools configured to 100 characters
+- Black and isort won't fight over formatting
+- Ruff respects Black's decisions (E501 ignored)
+
+## Supported Python Versions
+
+- Python 3.10+
+- Python 3.11
+- Python 3.12
+
+## Development
+
+When developing with hard-lint-py:
+
+### Pre-commit Validation
+Your code will be validated on every commit:
+```bash
+git commit -m "feat: your feature"
+# Runs: ruff check --fix → black → isort → commitlint
+```
+
+### Manual Validation
+Run validation checks manually:
+```bash
+# All checks
+make lint
+make format
+make test
+make test-cov
+
+# Individual tools
+poetry run ruff check src/ tests/
+poetry run black --check src/ tests/
+poetry run isort --check-only src/ tests/
+```
+
+### Quality Standards
+- ✅ 99% code coverage
+- ✅ No unused imports or variables
+- ✅ Consistent formatting (100 char lines)
+- ✅ Code complexity within limits
+- ✅ Modern Python syntax
+- ✅ No common bugs or design problems
+
+## License
+
+MIT
+
+## Author
+
+Naylson Ferreira

hard_lint_py-0.0.0/pyproject.toml

@@ -0,0 +1,127 @@
+[project]
+name = "hard-lint-py"
+version = "0.0.0"
+description = "Rigorous linting and code quality setup for Python projects with pre-commit hooks"
+authors = [
+    {name = "Naylson Ferreira", email = "naylsonfsa@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+keywords = ["linting", "pre-commit", "code-quality", "ruff", "black", "isort", "coverage"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "ruff>=0.1.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "pre-commit>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/naylsonferreira/hard-lint-py"
+Repository = "https://github.com/naylsonferreira/hard-lint-py.git"
+Issues = "https://github.com/naylsonferreira/hard-lint-py/issues"
+
+[project.scripts]
+hard-lint-py = "hard_lint_py.cli:main"
+
+[tool.poetry]
+packages = [{include = "hard_lint_py", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+ruff = "^0.1.0"
+black = "^23.0.0"
+isort = "^5.12.0"
+pre-commit = "^3.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+coverage = "^7.0.0"
+mypy = "^1.5.0"
+python-semantic-release = "^9.0.0"
+
+[tool.black]
+line-length = 100
+target-version = ["py310", "py311", "py312"]
+preview = true
+
+[tool.isort]
+profile = "black"
+line_length = 100
+include_trailing_comma = true
+use_parentheses = true
+ensure_newline_before_comments = true
+balanced_wrapping = true
+lines_after_imports = 2
+skip_gitignore = true
+known_first_party = ["hard_lint_py"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+select = [
+    "E",      # pycodestyle errors
+    "F",      # Pyflakes (unused imports)
+    "W",      # pycodestyle warnings
+    "I",      # isort (import sorting)
+    "N",      # pep8-naming
+    "C",      # mccabe complexity
+    "B",      # flake8-bugbear
+    "T",      # flake8-print (prohibit print statements)
+    "RUF",    # Ruff-specific rules
+    "UP",     # pyupgrade (modernize code)
+]
+ignore = [
+    "E501",   # Line too long (Black handles this)
+    "I001",   # Import sorting conflict with isort (let isort handle this)
+    "RUF001", # Ambiguous unicode character (too strict)
+    "T201",   # Allow print statements (CLI tool)
+]
+
+[tool.ruff.per-file-ignores]
+# Tests excluded due to import complexity
+"tests/*" = ["I001"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=src/hard_lint_py --cov-report=term-missing --strict-markers"
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+
+[tool.semantic_release]
+version_variable = "src/hard_lint_py/__init__.py:__version__"
+version_toml = ["pyproject.toml:project.version"]
+major_on_zero = false
+build_command = "pip install build && python -m build"
+
+[tool.semantic_release.branches.main]
+match = "main"
+
+[tool.semantic_release.changelog]
+template_dir = "templates"
+exclude_commit_patterns = []
+
+[tool.semantic_release.publish]
+dist_glob_patterns = ["dist/*"]
+upload_to_vcs_release = true
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

hard_lint_py-0.0.0/src/hard_lint_py/__init__.py

@@ -0,0 +1,6 @@
+from hard_lint_py.cli import main
+
+
+__version__ = "0.2.2"
+__author__ = "Naylson Ferreira"
+__all__ = ["main"]

hard_lint_py-0.0.0/src/hard_lint_py/cli.py

@@ -0,0 +1,141 @@
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from hard_lint_py.installer import HardLintInstaller
+
+
+def check_install_status():
+    """Check if hard-lint-py install was run and show warning if not."""
+    hardlint_dir = Path.cwd() / ".hardlint" / "_"
+    if not hardlint_dir.exists():
+        print("WARNING: Pre-commit hooks not installed!")
+        print("Run 'hard-lint-py install' to set up git hooks.")
+        print("(You can still use check/format commands without it)\n")
+
+
+def run_check(paths=None) -> int:
+    check_install_status()
+    target_paths = paths if paths else ["."]
+    try:
+        print(f"Running checks on {target_paths}...")
+        subprocess.run(["poetry", "run", "ruff", "check", *target_paths], check=True)
+        subprocess.run(
+            ["poetry", "run", "black", "--check", "--line-length", "100", *target_paths],
+            check=True,
+        )
+        subprocess.run(
+            [
+                "poetry",
+                "run",
+                "isort",
+                "--check-only",
+                "--profile",
+                "black",
+                "--line-length",
+                "100",
+                *target_paths,
+            ],
+            check=True,
+        )
+        print("All checks passed!")
+        return 0
+    except subprocess.CalledProcessError:
+        print("Checks failed.")
+        return 1
+
+
+def run_format(paths=None) -> int:
+    check_install_status()
+    target_paths = paths if paths else ["."]
+    try:
+        print(f"Running formatting on {target_paths}...")
+        subprocess.run(
+            ["poetry", "run", "black", "--line-length", "100", *target_paths], check=True
+        )
+        subprocess.run(
+            [
+                "poetry",
+                "run",
+                "isort",
+                "--profile",
+                "black",
+                "--line-length",
+                "100",
+                *target_paths,
+            ],
+            check=True,
+        )
+        subprocess.run(["poetry", "run", "ruff", "check", "--fix", *target_paths], check=True)
+        print("Formatting complete!")
+        return 0
+    except subprocess.CalledProcessError:
+        print("Formatting failed.")
+        return 1
+
+
+def run_verify(paths=None) -> int:
+    try:
+        print("Running verification (lint + tests)...")
+        if run_check(paths) != 0:
+            print("Lint checks failed. Aborting verification.")
+            return 1
+
+        print("Running tests...")
+        subprocess.run(["poetry", "run", "pytest"], check=True)
+        print("Verification complete! All checks and tests passed.")
+        return 0
+    except subprocess.CalledProcessError:
+        print("Tests failed.")
+        return 1
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Hard Lint CLI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    subparsers.add_parser("install", help="Install hardlint configuration")
+
+    check_parser = subparsers.add_parser("check", help="Run lint checks")
+    check_parser.add_argument("paths", nargs="*", help="Paths to check")
+
+    format_parser = subparsers.add_parser("format", help="Run formatting")
+    format_parser.add_argument("paths", nargs="*", help="Paths to format")
+
+    verify_parser = subparsers.add_parser("verify", help="Run verification (lint + tests)")
+    verify_parser.add_argument("paths", nargs="*", help="Paths to verify (passed to lint check)")
+
+    if len(sys.argv) == 1:
+        try:
+            installer = HardLintInstaller(Path.cwd())
+            installer.install()
+            print("Hardlint configuration installed successfully.")
+            return 0
+        except Exception as e:
+            print(f"Installation failed: {e}")
+            return 1
+
+    args = parser.parse_args()
+
+    if args.command == "install":
+        try:
+            installer = HardLintInstaller(Path.cwd())
+            installer.install()
+            print("Hardlint configuration installed successfully.")
+            return 0
+        except Exception as e:
+            print(f"Installation failed: {e}")
+            return 1
+    elif args.command == "check":
+        return run_check(args.paths)
+    elif args.command == "format":
+        return run_format(args.paths)
+    elif args.command == "verify":
+        return run_verify(args.paths)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hard_lint_py-0.0.0/src/hard_lint_py/installer.py

@@ -0,0 +1,84 @@
+import subprocess
+from pathlib import Path
+
+
+class HardLintInstaller:
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.git_dir = project_root / ".git"
+        self.pre_commit_dir = project_root / ".hardlint"
+        self.hooks_dir = self.pre_commit_dir / "_"
+        self.pyproject_path = project_root / "pyproject.toml"
+
+    def install(self) -> None:
+        if not self._check_git_repo():
+            raise RuntimeError("Not a Git repository. Initialize Git first with: git init")
+
+        if not self._check_pyproject():
+            raise RuntimeError("pyproject.toml not found in project root")
+
+        self._setup_pre_commit_hooks()
+        self._configure_git_hooks_path()
+        self._ensure_pyproject_config()
+
+    def _check_git_repo(self) -> bool:
+        return self.git_dir.exists()
+
+    def _check_pyproject(self) -> bool:
+        return self.pyproject_path.exists()
+
+    def _setup_pre_commit_hooks(self) -> None:
+        self.hooks_dir.mkdir(parents=True, exist_ok=True)
+
+        (self.pre_commit_dir / ".gitignore").write_text("*")
+
+        pre_commit_content = (
+            '#!/bin/sh\ncd "$(git rev-parse --show-toplevel)"\npoetry run hard-lint-py format .\n'
+        )
+        pre_commit_path = self.hooks_dir / "pre-commit"
+        pre_commit_path.write_text(pre_commit_content)
+        pre_commit_path.chmod(0o755)
+
+        commit_msg_content = (
+            "#!/bin/sh\n"
+            'cd "$(git rev-parse --show-toplevel)"\n'
+            'MESSAGE=$(cat "$1")\n'
+            'poetry run python -c "import sys; import re; '
+            "pattern = r'^(feat|fix|docs|style|refactor|perf|test|chore)'; "
+            "msg = '''$MESSAGE'''; "
+            'sys.exit(0 if re.match(pattern, msg) else 1)"\n'
+        )
+        commit_msg_path = self.hooks_dir / "commit-msg"
+        commit_msg_path.write_text(commit_msg_content)
+        commit_msg_path.chmod(0o755)
+
+    def _configure_git_hooks_path(self) -> None:
+        try:
+            subprocess.run(
+                ["git", "config", "core.hooksPath", ".hardlint/_"],
+                cwd=self.project_root,
+                check=True,
+                capture_output=True,
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to configure Git: {e.stderr.decode()}") from e
+
+    def _ensure_pyproject_config(self) -> None:
+        pyproject_content = self.pyproject_path.read_text()
+
+        if "[tool.ruff]" not in pyproject_content:
+            pyproject_content += "\n[tool.ruff]\n"
+            pyproject_content += "line-length = 100\n"
+            pyproject_content += 'target-version = "py310"\n'
+            pyproject_content += 'select = ["E", "F", "W", "I", "N", "C", "B"]\n'
+
+        if "[tool.black]" not in pyproject_content:
+            pyproject_content += "\n[tool.black]\n"
+            pyproject_content += "line-length = 100\n"
+
+        if "[tool.isort]" not in pyproject_content:
+            pyproject_content += "\n[tool.isort]\n"
+            pyproject_content += 'profile = "black"\n'
+            pyproject_content += "line_length = 100\n"
+
+        self.pyproject_path.write_text(pyproject_content)