style: Run black formatter on 16 files

Applied black formatting to files modified in linting fixes: Source files (8): - config_extractor.py - doc_scraper.py - how_to_guide_builder.py - llms_txt_downloader.py - llms_txt_parser.py - pattern_recognizer.py - test_example_extractor.py - unified_codebase_analyzer.py Test files (8): - test_architecture_scenarios.py - test_async_scraping.py - test_github_scraper.py - test_guide_enhancer.py - test_install_agent.py - test_issue_219_e2e.py - test_llms_txt_downloader.py - test_skip_llms_txt.py All formatting issues resolved. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-01-17 23:56:24 +03:00
parent 9666938eb0
commit 9d43956b1d
16 changed files with 1044 additions and 335 deletions
--- a/tests/test_architecture_scenarios.py
+++ b/tests/test_architecture_scenarios.py
@@ -29,7 +29,10 @@ from skill_seekers.cli.github_fetcher import (
    ThreeStreamData,
 )
 from skill_seekers.cli.merge_sources import RuleBasedMerger, categorize_issues_by_topic
-from skill_seekers.cli.unified_codebase_analyzer import AnalysisResult, UnifiedCodebaseAnalyzer
+from skill_seekers.cli.unified_codebase_analyzer import (
+    AnalysisResult,
+    UnifiedCodebaseAnalyzer,
+)


 class TestScenario1GitHubThreeStream:
@@ -67,7 +70,8 @@ class TestScenario1GitHubThreeStream:
        # Create code files
        src_dir = repo_dir / "src"
        src_dir.mkdir()
-        (src_dir / "auth.py").write_text("""
+        (src_dir / "auth.py").write_text(
+            """
 # OAuth authentication
 def google_provider(client_id, client_secret):
    '''Google OAuth provider'''
@@ -76,20 +80,24 @@ def google_provider(client_id, client_secret):
 def azure_provider(tenant_id, client_id):
    '''Azure OAuth provider'''
    return Provider('azure', tenant_id, client_id)
-""")
-        (src_dir / "async_tools.py").write_text("""
+"""
+        )
+        (src_dir / "async_tools.py").write_text(
+            """
 import asyncio

 async def async_tool():
    '''Async tool decorator'''
    await asyncio.sleep(1)
    return "result"
-""")
+"""
+        )

        # Create test files
        tests_dir = repo_dir / "tests"
        tests_dir.mkdir()
-        (tests_dir / "test_auth.py").write_text("""
+        (tests_dir / "test_auth.py").write_text(
+            """
 def test_google_provider():
    provider = google_provider('id', 'secret')
    assert provider.name == 'google'
@@ -97,10 +105,12 @@ def test_google_provider():
 def test_azure_provider():
    provider = azure_provider('tenant', 'id')
    assert provider.name == 'azure'
-""")
+"""
+        )

        # Create docs
-        (repo_dir / "README.md").write_text("""
+        (repo_dir / "README.md").write_text(
+            """
 # FastMCP

 FastMCP is a Python framework for building MCP servers.
@@ -116,26 +126,33 @@ pip install fastmcp
 - OAuth authentication (Google, Azure, GitHub)
 - Async/await support
 - Easy testing with pytest
-""")
+"""
+        )

-        (repo_dir / "CONTRIBUTING.md").write_text("""
+        (repo_dir / "CONTRIBUTING.md").write_text(
+            """
 # Contributing

 Please follow these guidelines when contributing.
-""")
+"""
+        )

        docs_dir = repo_dir / "docs"
        docs_dir.mkdir()
-        (docs_dir / "oauth.md").write_text("""
+        (docs_dir / "oauth.md").write_text(
+            """
 # OAuth Guide

 How to set up OAuth providers.
-""")
-        (docs_dir / "async.md").write_text("""
+"""
+        )
+        (docs_dir / "async.md").write_text(
+            """
 # Async Guide

 How to use async tools.
-""")
+"""
+        )

        return repo_dir

@@ -186,11 +203,15 @@ How to use async tools.
            ],
        }

-    def test_scenario_1_github_three_stream_fetcher(self, mock_github_repo, mock_github_api_data):
+    def test_scenario_1_github_three_stream_fetcher(
+        self, mock_github_repo, mock_github_api_data
+    ):
        """Test GitHub three-stream fetcher with mock data."""
        # Create fetcher with mock
        with (
-            patch.object(GitHubThreeStreamFetcher, "clone_repo", return_value=mock_github_repo),
+            patch.object(
+                GitHubThreeStreamFetcher, "clone_repo", return_value=mock_github_repo
+            ),
            patch.object(
                GitHubThreeStreamFetcher,
                "fetch_github_metadata",
@@ -202,7 +223,9 @@ How to use async tools.
                return_value=mock_github_api_data["issues"],
            ),
        ):
-            fetcher = GitHubThreeStreamFetcher("https://github.com/jlowin/fastmcp", interactive=False)
+            fetcher = GitHubThreeStreamFetcher(
+                "https://github.com/jlowin/fastmcp", interactive=False
+            )
            three_streams = fetcher.fetch()

            # Verify 3 streams exist
@@ -228,10 +251,14 @@ How to use async tools.
            assert len(three_streams.insights_stream.known_solutions) >= 1
            assert len(three_streams.insights_stream.top_labels) >= 2

-    def test_scenario_1_unified_analyzer_github(self, mock_github_repo, mock_github_api_data):
+    def test_scenario_1_unified_analyzer_github(
+        self, mock_github_repo, mock_github_api_data
+    ):
        """Test unified analyzer with GitHub source."""
        with (
-            patch.object(GitHubThreeStreamFetcher, "clone_repo", return_value=mock_github_repo),
+            patch.object(
+                GitHubThreeStreamFetcher, "clone_repo", return_value=mock_github_repo
+            ),
            patch.object(
                GitHubThreeStreamFetcher,
                "fetch_github_metadata",
@@ -259,16 +286,24 @@ How to use async tools.
                    {"name": "test_azure_provider", "file": "test_auth.py"},
                ],
                "c3_2_examples_count": 2,
-                "c3_3_guides": [{"title": "OAuth Setup Guide", "file": "docs/oauth.md"}],
+                "c3_3_guides": [
+                    {"title": "OAuth Setup Guide", "file": "docs/oauth.md"}
+                ],
                "c3_4_configs": [],
                "c3_7_architecture": [
-                    {"pattern": "Service Layer", "description": "OAuth provider abstraction"}
+                    {
+                        "pattern": "Service Layer",
+                        "description": "OAuth provider abstraction",
+                    }
                ],
            }

            analyzer = UnifiedCodebaseAnalyzer()
            result = analyzer.analyze(
-                source="https://github.com/jlowin/fastmcp", depth="c3x", fetch_github_metadata=True, interactive=False
+                source="https://github.com/jlowin/fastmcp",
+                depth="c3x",
+                fetch_github_metadata=True,
+                interactive=False,
            )

            # Verify result structure
@@ -300,7 +335,9 @@ How to use async tools.
                {
                    "name": "fastmcp-oauth",
                    "description": "OAuth authentication for FastMCP",
-                    "categories": {"oauth": ["oauth", "auth", "provider", "google", "azure"]},
+                    "categories": {
+                        "oauth": ["oauth", "auth", "provider", "google", "azure"]
+                    },
                }
            )
        )
@@ -454,7 +491,9 @@ pip install fastmcp
        # Check content quality (Architecture Section 8.2)
        assert "Issue #42" in router_md, "Missing issue references"
        assert "⭐" in router_md or "Stars:" in router_md, "Missing GitHub metadata"
-        assert "Quick Start" in router_md or "README" in router_md, "Missing README content"
+        assert (
+            "Quick Start" in router_md or "README" in router_md
+        ), "Missing README content"


 class TestScenario2MultiSource:
@@ -495,14 +534,30 @@ class TestScenario2MultiSource:
        """Test categorizing GitHub issues by topic."""
        problems = [
            {"number": 42, "title": "OAuth setup fails", "labels": ["oauth", "bug"]},
-            {"number": 38, "title": "Async tools not working", "labels": ["async", "question"]},
-            {"number": 35, "title": "Testing with pytest", "labels": ["testing", "question"]},
-            {"number": 30, "title": "Google OAuth redirect", "labels": ["oauth", "question"]},
+            {
+                "number": 38,
+                "title": "Async tools not working",
+                "labels": ["async", "question"],
+            },
+            {
+                "number": 35,
+                "title": "Testing with pytest",
+                "labels": ["testing", "question"],
+            },
+            {
+                "number": 30,
+                "title": "Google OAuth redirect",
+                "labels": ["oauth", "question"],
+            },
        ]

        solutions = [
            {"number": 25, "title": "Fixed OAuth redirect", "labels": ["oauth", "bug"]},
-            {"number": 20, "title": "Async timeout solution", "labels": ["async", "bug"]},
+            {
+                "number": 20,
+                "title": "Async timeout solution",
+                "labels": ["async", "bug"],
+            },
        ]

        topics = ["oauth", "async", "testing"]
@@ -533,7 +588,12 @@ class TestScenario2MultiSource:
    def test_scenario_2_conflict_detection(self):
        """Test conflict detection between docs and code."""
        # Mock API data from docs
-        api_data = {"GoogleProvider": {"params": ["app_id", "app_secret"], "source": "html_docs"}}
+        api_data = {
+            "GoogleProvider": {
+                "params": ["app_id", "app_secret"],
+                "source": "html_docs",
+            }
+        }

        # Mock GitHub docs
        github_docs = {"readme": "Use client_id and client_secret for Google OAuth"}
@@ -557,23 +617,33 @@ class TestScenario2MultiSource:
        # Layer 4: GitHub insights (community knowledge)

        # Mock source 1 (HTML docs)
-        source1_data = {"api": [{"name": "GoogleProvider", "params": ["app_id", "app_secret"]}]}
+        source1_data = {
+            "api": [{"name": "GoogleProvider", "params": ["app_id", "app_secret"]}]
+        }

        # Mock source 2 (GitHub C3.x)
        source2_data = {
-            "api": [{"name": "GoogleProvider", "params": ["client_id", "client_secret"]}]
+            "api": [
+                {"name": "GoogleProvider", "params": ["client_id", "client_secret"]}
+            ]
        }

        # Mock GitHub streams
        _github_streams = ThreeStreamData(
            code_stream=CodeStream(directory=Path("/tmp"), files=[]),
            docs_stream=DocsStream(
-                readme="Use client_id and client_secret", contributing=None, docs_files=[]
+                readme="Use client_id and client_secret",
+                contributing=None,
+                docs_files=[],
            ),
            insights_stream=InsightsStream(
                metadata={"stars": 1000},
                common_problems=[
-                    {"number": 42, "title": "OAuth parameter confusion", "labels": ["oauth"]}
+                    {
+                        "number": 42,
+                        "title": "OAuth parameter confusion",
+                        "labels": ["oauth"],
+                    }
                ],
                known_solutions=[],
                top_labels=[],
@@ -581,7 +651,9 @@ class TestScenario2MultiSource:
        )

        # Create merger with required arguments
-        merger = RuleBasedMerger(docs_data=source1_data, github_data=source2_data, conflicts=[])
+        merger = RuleBasedMerger(
+            docs_data=source1_data, github_data=source2_data, conflicts=[]
+        )

        # Merge using merge_all() method
        merged = merger.merge_all()
@@ -625,7 +697,8 @@ class TestScenario3LocalCodebase:
        # Create source files
        src_dir = project_dir / "src"
        src_dir.mkdir()
-        (src_dir / "database.py").write_text("""
+        (src_dir / "database.py").write_text(
+            """
 class DatabaseConnection:
    '''Database connection pool'''
    def __init__(self, host, port):
@@ -635,9 +708,11 @@ class DatabaseConnection:
    def connect(self):
        '''Establish connection'''
        pass
-""")
+"""
+        )

-        (src_dir / "api.py").write_text("""
+        (src_dir / "api.py").write_text(
+            """
 from flask import Flask

 app = Flask(__name__)
@@ -646,16 +721,19 @@ app = Flask(__name__)
 def get_users():
    '''Get all users'''
    return {'users': []}
-""")
+"""
+        )

        # Create tests
        tests_dir = project_dir / "tests"
        tests_dir.mkdir()
-        (tests_dir / "test_database.py").write_text("""
+        (tests_dir / "test_database.py").write_text(
+            """
 def test_connection():
    conn = DatabaseConnection('localhost', 5432)
    assert conn.host == 'localhost'
-""")
+"""
+        )

        return project_dir

@@ -692,8 +770,12 @@ def test_connection():
            mock_c3x.return_value = {
                "files": ["database.py", "api.py"],
                "analysis_type": "c3x",
-                "c3_1_patterns": [{"name": "Singleton", "count": 1, "file": "database.py"}],
-                "c3_2_examples": [{"name": "test_connection", "file": "test_database.py"}],
+                "c3_1_patterns": [
+                    {"name": "Singleton", "count": 1, "file": "database.py"}
+                ],
+                "c3_2_examples": [
+                    {"name": "test_connection", "file": "test_database.py"}
+                ],
                "c3_2_examples_count": 1,
                "c3_3_guides": [],
                "c3_4_configs": [],
@@ -885,7 +967,9 @@ Based on analysis of GitHub issues:
        print(f"\nGitHub overhead: {github_overhead} lines")

        # Architecture target: 20-60 lines
-        assert 20 <= github_overhead <= 60, f"GitHub overhead {github_overhead} not in range 20-60"
+        assert (
+            20 <= github_overhead <= 60
+        ), f"GitHub overhead {github_overhead} not in range 20-60"

    def test_router_size_within_limits(self):
        """Test router size is 150±20 lines (Architecture Section 8.1, Line 1970)."""
@@ -893,7 +977,9 @@ Based on analysis of GitHub issues:
        router_lines = 150  # Simulated count

        # Architecture target: 150 lines (±20)
-        assert 130 <= router_lines <= 170, f"Router size {router_lines} not in range 130-170"
+        assert (
+            130 <= router_lines <= 170
+        ), f"Router size {router_lines} not in range 130-170"

    def test_content_quality_requirements(self):
        """Test content quality (Architecture Section 8.2, Lines 1977-2014)."""
@@ -935,9 +1021,9 @@ provider = GitHubProvider(client_id="...", client_secret="...")

        # Check minimum 3 code examples
        code_blocks = sub_skill_md.count("```")
-        assert code_blocks >= 6, (
-            f"Need at least 3 code examples (6 markers), found {code_blocks // 2}"
-        )
+        assert (
+            code_blocks >= 6
+        ), f"Need at least 3 code examples (6 markers), found {code_blocks // 2}"

        # Check language tags
        assert "```python" in sub_skill_md, "Code blocks must have language tags"
@@ -952,9 +1038,9 @@ provider = GitHubProvider(client_id="...", client_secret="...")

        # Check solution indicators for closed issues
        if "closed" in sub_skill_md.lower():
-            assert "✅" in sub_skill_md or "Solution" in sub_skill_md, (
-                "Closed issues should indicate solution found"
-            )
+            assert (
+                "✅" in sub_skill_md or "Solution" in sub_skill_md
+            ), "Closed issues should indicate solution found"


 class TestTokenEfficiencyCalculation:
@@ -991,9 +1077,9 @@ class TestTokenEfficiencyCalculation:

        # With selective loading and caching, achieve 35-40%
        # Even conservative estimate shows 29.5%, actual usage patterns show 35-40%
-        assert reduction_percent >= 29, (
-            f"Token reduction {reduction_percent:.1f}% below 29% (conservative target)"
-        )
+        assert (
+            reduction_percent >= 29
+        ), f"Token reduction {reduction_percent:.1f}% below 29% (conservative target)"


 if __name__ == "__main__":
--- a/tests/test_async_scraping.py
+++ b/tests/test_async_scraping.py
@@ -103,7 +103,9 @@ class TestAsyncScrapeMethods(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=True)
                self.assertTrue(hasattr(converter, "scrape_page_async"))
-                self.assertTrue(asyncio.iscoroutinefunction(converter.scrape_page_async))
+                self.assertTrue(
+                    asyncio.iscoroutinefunction(converter.scrape_page_async)
+                )
            finally:
                os.chdir(self.original_cwd)

@@ -177,9 +179,12 @@ class TestAsyncRouting(unittest.TestCase):
                converter = DocToSkillConverter(config, dry_run=True)

                # Mock scrape_all_async to verify it does NOT get called
-                with patch.object(
-                    converter, "scrape_all_async", new_callable=AsyncMock
-                ) as mock_async, patch.object(converter, "_try_llms_txt", return_value=False):
+                with (
+                    patch.object(
+                        converter, "scrape_all_async", new_callable=AsyncMock
+                    ) as mock_async,
+                    patch.object(converter, "_try_llms_txt", return_value=False),
+                ):
                    converter.scrape_all()
                    # Verify async version was NOT called
                    mock_async.assert_not_called()
@@ -258,7 +263,9 @@ class TestAsyncErrorHandling(unittest.TestCase):

                    async with httpx.AsyncClient() as client:
                        # Mock client.get to raise exception
-                        with patch.object(client, "get", side_effect=httpx.HTTPError("Test error")):
+                        with patch.object(
+                            client, "get", side_effect=httpx.HTTPError("Test error")
+                        ):
                            # Should not raise exception, just log error
                            await converter.scrape_page_async(
                                "https://example.com/test", semaphore, client
@@ -316,7 +323,10 @@ class TestAsyncLlmsTxtIntegration(unittest.TestCase):
                converter = DocToSkillConverter(config, dry_run=False)

                # Mock _try_llms_txt to return True (llms.txt found)
-                with patch.object(converter, "_try_llms_txt", return_value=True), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(converter, "_try_llms_txt", return_value=True),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    # If llms.txt succeeded, async scraping should be skipped
                    # Verify by checking that pages were not scraped
--- a/tests/test_github_scraper.py
+++ b/tests/test_github_scraper.py
@@ -62,7 +62,11 @@ class TestGitHubScraperInitialization(unittest.TestCase):

    def test_init_with_token_from_config(self):
        """Test initialization with token from config"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": "test_token_123"}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": "test_token_123",
+        }

        with patch("skill_seekers.cli.github_scraper.Github") as mock_github:
            _scraper = self.GitHubScraper(config)
@@ -72,7 +76,10 @@ class TestGitHubScraperInitialization(unittest.TestCase):
        """Test initialization with token from environment variable"""
        config = {"repo": "facebook/react", "name": "react", "github_token": None}

-        with patch.dict(os.environ, {"GITHUB_TOKEN": "env_token_456"}), patch("skill_seekers.cli.github_scraper.Github") as mock_github:
+        with (
+            patch.dict(os.environ, {"GITHUB_TOKEN": "env_token_456"}),
+            patch("skill_seekers.cli.github_scraper.Github") as mock_github,
+        ):
            _scraper = self.GitHubScraper(config)
            mock_github.assert_called_once_with("env_token_456")

@@ -80,14 +87,21 @@ class TestGitHubScraperInitialization(unittest.TestCase):
        """Test initialization without authentication"""
        config = {"repo": "facebook/react", "name": "react", "github_token": None}

-        with patch("skill_seekers.cli.github_scraper.Github"), patch.dict(os.environ, {}, clear=True):
+        with (
+            patch("skill_seekers.cli.github_scraper.Github"),
+            patch.dict(os.environ, {}, clear=True),
+        ):
            scraper = self.GitHubScraper(config)
            # Should create unauthenticated client
            self.assertIsNotNone(scraper.github)

    def test_token_priority_env_over_config(self):
        """Test that GITHUB_TOKEN env var takes priority over config"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": "config_token"}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": "config_token",
+        }

        with patch.dict(os.environ, {"GITHUB_TOKEN": "env_token"}):
            scraper = self.GitHubScraper(config)
@@ -120,7 +134,9 @@ class TestREADMEExtraction(unittest.TestCase):
            scraper._extract_readme()

            self.assertIn("readme", scraper.extracted_data)
-            self.assertEqual(scraper.extracted_data["readme"], "# React\n\nA JavaScript library")
+            self.assertEqual(
+                scraper.extracted_data["readme"], "# React\n\nA JavaScript library"
+            )

    def test_extract_readme_tries_multiple_locations(self):
        """Test that README extraction tries multiple file locations"""
@@ -177,7 +193,10 @@ class TestLanguageDetection(unittest.TestCase):
        with patch("skill_seekers.cli.github_scraper.Github"):
            scraper = self.GitHubScraper(config)
            scraper.repo = Mock()
-            scraper.repo.get_languages.return_value = {"JavaScript": 8000, "TypeScript": 2000}
+            scraper.repo.get_languages.return_value = {
+                "JavaScript": 8000,
+                "TypeScript": 2000,
+            }

            scraper._extract_languages()

@@ -221,7 +240,12 @@ class TestIssuesExtraction(unittest.TestCase):

    def test_extract_issues_success(self):
        """Test successful issues extraction"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": None, "max_issues": 10}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": None,
+            "max_issues": 10,
+        }

        # Create mock issues
        mock_label1 = Mock()
@@ -286,7 +310,12 @@ class TestIssuesExtraction(unittest.TestCase):

    def test_extract_issues_filters_pull_requests(self):
        """Test that pull requests are filtered out from issues"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": None, "max_issues": 10}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": None,
+            "max_issues": 10,
+        }

        # Create mock issue (need all required attributes)
        mock_issue = Mock()
@@ -321,7 +350,12 @@ class TestIssuesExtraction(unittest.TestCase):

    def test_extract_issues_respects_max_limit(self):
        """Test that max_issues limit is respected"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": None, "max_issues": 2}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": None,
+            "max_issues": 2,
+        }

        # Create 5 mock issues
        mock_issues = []
@@ -443,9 +477,15 @@ class TestReleasesExtraction(unittest.TestCase):
        mock_release1.prerelease = False
        mock_release1.created_at = datetime(2023, 3, 1)
        mock_release1.published_at = datetime(2023, 3, 1)
-        mock_release1.html_url = "https://github.com/facebook/react/releases/tag/v18.0.0"
-        mock_release1.tarball_url = "https://github.com/facebook/react/archive/v18.0.0.tar.gz"
-        mock_release1.zipball_url = "https://github.com/facebook/react/archive/v18.0.0.zip"
+        mock_release1.html_url = (
+            "https://github.com/facebook/react/releases/tag/v18.0.0"
+        )
+        mock_release1.tarball_url = (
+            "https://github.com/facebook/react/archive/v18.0.0.tar.gz"
+        )
+        mock_release1.zipball_url = (
+            "https://github.com/facebook/react/archive/v18.0.0.zip"
+        )

        mock_release2 = Mock()
        mock_release2.tag_name = "v18.0.0-rc.0"
@@ -455,9 +495,15 @@ class TestReleasesExtraction(unittest.TestCase):
        mock_release2.prerelease = True
        mock_release2.created_at = datetime(2023, 2, 1)
        mock_release2.published_at = datetime(2023, 2, 1)
-        mock_release2.html_url = "https://github.com/facebook/react/releases/tag/v18.0.0-rc.0"
-        mock_release2.tarball_url = "https://github.com/facebook/react/archive/v18.0.0-rc.0.tar.gz"
-        mock_release2.zipball_url = "https://github.com/facebook/react/archive/v18.0.0-rc.0.zip"
+        mock_release2.html_url = (
+            "https://github.com/facebook/react/releases/tag/v18.0.0-rc.0"
+        )
+        mock_release2.tarball_url = (
+            "https://github.com/facebook/react/archive/v18.0.0-rc.0.tar.gz"
+        )
+        mock_release2.zipball_url = (
+            "https://github.com/facebook/react/archive/v18.0.0-rc.0.zip"
+        )

        with patch("skill_seekers.cli.github_scraper.Github"):
            scraper = self.GitHubScraper(config)
@@ -566,7 +612,9 @@ class TestGitHubToSkillConverter(unittest.TestCase):
        config = {"repo": "facebook/react", "name": "test", "description": "Test skill"}

        # Override data file path
-        with patch("skill_seekers.cli.github_scraper.GitHubToSkillConverter.__init__") as mock_init:
+        with patch(
+            "skill_seekers.cli.github_scraper.GitHubToSkillConverter.__init__"
+        ) as mock_init:
            mock_init.return_value = None
            converter = self.GitHubToSkillConverter(config)
            converter.data_file = str(self.data_file)
@@ -733,7 +781,8 @@ class TestSymlinkHandling(unittest.TestCase):
            # Should successfully extract README content
            self.assertIn("readme", scraper.extracted_data)
            self.assertEqual(
-                scraper.extracted_data["readme"], "# AI SDK\n\nThe AI SDK is a TypeScript toolkit"
+                scraper.extracted_data["readme"],
+                "# AI SDK\n\nThe AI SDK is a TypeScript toolkit",
            )

    def test_extract_changelog_with_symlink(self):
@@ -815,7 +864,8 @@ class TestSymlinkHandling(unittest.TestCase):
                # Should download via download_url
                self.assertEqual(result, "# Changelog\n\n## v1.0.0\n- Initial release")
                mock_requests.assert_called_once_with(
-                    "https://raw.githubusercontent.com/ccxt/ccxt/master/CHANGELOG.md", timeout=30
+                    "https://raw.githubusercontent.com/ccxt/ccxt/master/CHANGELOG.md",
+                    timeout=30,
                )

    def test_extract_changelog_large_file(self):
@@ -950,7 +1000,9 @@ class TestErrorHandling(unittest.TestCase):
        with patch("skill_seekers.cli.github_scraper.Github"):
            scraper = self.GitHubScraper(config)
            scraper.repo = None
-            scraper.github.get_repo = Mock(side_effect=GithubException(404, "Not found"))
+            scraper.github.get_repo = Mock(
+                side_effect=GithubException(404, "Not found")
+            )

            # Should raise ValueError with helpful message
            with self.assertRaises(ValueError) as context:
@@ -960,12 +1012,19 @@ class TestErrorHandling(unittest.TestCase):

    def test_rate_limit_error(self):
        """Test handling of rate limit errors"""
-        config = {"repo": "facebook/react", "name": "react", "github_token": None, "max_issues": 10}
+        config = {
+            "repo": "facebook/react",
+            "name": "react",
+            "github_token": None,
+            "max_issues": 10,
+        }

        with patch("skill_seekers.cli.github_scraper.Github"):
            scraper = self.GitHubScraper(config)
            scraper.repo = Mock()
-            scraper.repo.get_issues.side_effect = GithubException(403, "Rate limit exceeded")
+            scraper.repo.get_issues.side_effect = GithubException(
+                403, "Rate limit exceeded"
+            )

            # Should handle gracefully and log warning
            scraper._extract_issues()
--- a/tests/test_guide_enhancer.py
+++ b/tests/test_guide_enhancer.py
@@ -28,9 +28,13 @@ class TestGuideEnhancerModeDetection:

    def test_auto_mode_with_api_key(self):
        """Test auto mode detects API when key present and library available"""
-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="auto")
            # Will be 'api' if library available, otherwise 'local' or 'none'
@@ -80,7 +84,12 @@ class TestGuideEnhancerStepDescriptions:
    def test_enhance_step_descriptions_none_mode(self):
        """Test step descriptions in none mode returns empty"""
        enhancer = GuideEnhancer(mode="none")
-        steps = [{"description": "scraper.scrape(url)", "code": "result = scraper.scrape(url)"}]
+        steps = [
+            {
+                "description": "scraper.scrape(url)",
+                "code": "result = scraper.scrape(url)",
+            }
+        ]
        result = enhancer.enhance_step_descriptions(steps)
        assert result == []

@@ -99,9 +108,13 @@ class TestGuideEnhancerStepDescriptions:
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -163,9 +176,13 @@ class TestGuideEnhancerTroubleshooting:
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -175,7 +192,9 @@ class TestGuideEnhancerTroubleshooting:

            guide_data = {
                "title": "Test Guide",
-                "steps": [{"description": "import requests", "code": "import requests"}],
+                "steps": [
+                    {"description": "import requests", "code": "import requests"}
+                ],
                "language": "python",
            }
            result = enhancer.enhance_troubleshooting(guide_data)
@@ -224,9 +243,13 @@ class TestGuideEnhancerPrerequisites:
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -267,9 +290,13 @@ class TestGuideEnhancerNextSteps:
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -277,7 +304,10 @@ class TestGuideEnhancerNextSteps:

            enhancer.client = Mock()

-            guide_data = {"title": "How to Scrape Docs", "description": "Basic scraping"}
+            guide_data = {
+                "title": "How to Scrape Docs",
+                "description": "Basic scraping",
+            }
            result = enhancer.enhance_next_steps(guide_data)

            assert len(result) == 3
@@ -307,9 +337,13 @@ class TestGuideEnhancerUseCases:
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -358,7 +392,11 @@ class TestGuideEnhancerFullWorkflow:
        mock_call.return_value = json.dumps(
            {
                "step_descriptions": [
-                    {"step_index": 0, "explanation": "Import required libraries", "variations": []},
+                    {
+                        "step_index": 0,
+                        "explanation": "Import required libraries",
+                        "variations": [],
+                    },
                    {
                        "step_index": 1,
                        "explanation": "Initialize scraper instance",
@@ -374,16 +412,24 @@ class TestGuideEnhancerFullWorkflow:
                    }
                ],
                "prerequisites_detailed": [
-                    {"name": "requests", "why": "HTTP client", "setup": "pip install requests"}
+                    {
+                        "name": "requests",
+                        "why": "HTTP client",
+                        "setup": "pip install requests",
+                    }
                ],
                "next_steps": ["How to add authentication"],
                "use_cases": ["Automate documentation extraction"],
            }
        )

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}), patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True), patch(
-            "skill_seekers.cli.guide_enhancer.anthropic", create=True
-        ) as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "sk-ant-test"}),
+            patch("skill_seekers.cli.guide_enhancer.ANTHROPIC_AVAILABLE", True),
+            patch(
+                "skill_seekers.cli.guide_enhancer.anthropic", create=True
+            ) as mock_anthropic,
+        ):
            mock_anthropic.Anthropic = Mock()
            enhancer = GuideEnhancer(mode="api")
            if enhancer.mode != "api":
@@ -415,7 +461,9 @@ class TestGuideEnhancerFullWorkflow:
        """Test graceful fallback on enhancement error"""
        enhancer = GuideEnhancer(mode="none")

-        with patch.object(enhancer, "enhance_guide", side_effect=Exception("API error")):
+        with patch.object(
+            enhancer, "enhance_guide", side_effect=Exception("API error")
+        ):
            guide_data = {
                "title": "Test",
                "steps": [],
@@ -485,7 +533,9 @@ class TestGuideEnhancerPromptGeneration:

        guide_data = {
            "title": "How to Test",
-            "steps": [{"description": "Write test", "code": "def test_example(): pass"}],
+            "steps": [
+                {"description": "Write test", "code": "def test_example(): pass"}
+            ],
            "language": "python",
            "prerequisites": ["pytest"],
        }
@@ -533,7 +583,9 @@ class TestGuideEnhancerResponseParsing:

        response = json.dumps(
            {
-                "step_descriptions": [{"step_index": 0, "explanation": "Test", "variations": []}],
+                "step_descriptions": [
+                    {"step_index": 0, "explanation": "Test", "variations": []}
+                ],
                "troubleshooting": [],
                "prerequisites_detailed": [],
                "next_steps": [],
--- a/tests/test_install_agent.py
+++ b/tests/test_install_agent.py
@@ -174,7 +174,9 @@ class TestInstallToAgent:
        self.skill_dir.mkdir()

        # Create SKILL.md
-        (self.skill_dir / "SKILL.md").write_text("# Test Skill\n\nThis is a test skill.")
+        (self.skill_dir / "SKILL.md").write_text(
+            "# Test Skill\n\nThis is a test skill."
+        )

        # Create references directory with files
        refs_dir = self.skill_dir / "references"
@@ -195,8 +197,13 @@ class TestInstallToAgent:
        with tempfile.TemporaryDirectory() as agent_tmpdir:
            agent_path = Path(agent_tmpdir) / ".claude" / "skills"

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", force=True)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", force=True
+                )

                assert success is True
                target_path = agent_path / "test-skill"
@@ -208,8 +215,13 @@ class TestInstallToAgent:
        with tempfile.TemporaryDirectory() as agent_tmpdir:
            agent_path = Path(agent_tmpdir) / ".claude" / "skills"

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", force=True)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", force=True
+                )

                assert success is True
                target_path = agent_path / "test-skill"
@@ -230,8 +242,13 @@ class TestInstallToAgent:
        with tempfile.TemporaryDirectory() as agent_tmpdir:
            agent_path = Path(agent_tmpdir) / ".claude" / "skills"

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", force=True)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", force=True
+                )

                assert success is True
                target_path = agent_path / "test-skill"
@@ -248,8 +265,13 @@ class TestInstallToAgent:
            target_path = agent_path / "test-skill"
            target_path.mkdir(parents=True)

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", force=False)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", force=False
+                )

                assert success is False
                assert "already installed" in message.lower()
@@ -263,8 +285,13 @@ class TestInstallToAgent:
            target_path.mkdir(parents=True)
            (target_path / "old_file.txt").write_text("old content")

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", force=True)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", force=True
+                )

                assert success is True
                # Old file should be gone
@@ -297,8 +324,13 @@ class TestInstallToAgent:
        with tempfile.TemporaryDirectory() as agent_tmpdir:
            agent_path = Path(agent_tmpdir) / ".claude" / "skills"

-            with patch("skill_seekers.cli.install_agent.get_agent_path", return_value=agent_path):
-                success, message = install_to_agent(self.skill_dir, "claude", dry_run=True)
+            with patch(
+                "skill_seekers.cli.install_agent.get_agent_path",
+                return_value=agent_path,
+            ):
+                success, message = install_to_agent(
+                    self.skill_dir, "claude", dry_run=True
+                )

                assert success is True
                assert "DRY RUN" in message
@@ -329,7 +361,8 @@ class TestInstallToAllAgents:
                return Path(agent_tmpdir) / f".{agent_name}" / "skills"

            with patch(
-                "skill_seekers.cli.install_agent.get_agent_path", side_effect=mock_get_agent_path
+                "skill_seekers.cli.install_agent.get_agent_path",
+                side_effect=mock_get_agent_path,
            ):
                results = install_to_all_agents(self.skill_dir, force=True)

@@ -360,7 +393,8 @@ class TestInstallToAllAgents:
                return Path(agent_tmpdir) / f".{agent_name}" / "skills"

            with patch(
-                "skill_seekers.cli.install_agent.get_agent_path", side_effect=mock_get_agent_path
+                "skill_seekers.cli.install_agent.get_agent_path",
+                side_effect=mock_get_agent_path,
            ):
                # Without force - should fail
                results_no_force = install_to_all_agents(self.skill_dir, force=False)
@@ -415,7 +449,10 @@ class TestInstallAgentCLI:

    def test_cli_requires_agent_flag(self):
        """Test that CLI fails without --agent flag."""
-        with pytest.raises(SystemExit) as exc_info, patch("sys.argv", ["install_agent.py", str(self.skill_dir)]):
+        with (
+            pytest.raises(SystemExit) as exc_info,
+            patch("sys.argv", ["install_agent.py", str(self.skill_dir)]),
+        ):
            main()

        # Missing required argument exits with code 2
@@ -428,17 +465,29 @@ class TestInstallAgentCLI:
            def mock_get_agent_path(agent_name, _project_root=None):
                return Path(agent_tmpdir) / f".{agent_name}" / "skills"

-            with patch(
-                "skill_seekers.cli.install_agent.get_agent_path", side_effect=mock_get_agent_path
-            ), patch(
-                "sys.argv",
-                ["install_agent.py", str(self.skill_dir), "--agent", "claude", "--dry-run"],
+            with (
+                patch(
+                    "skill_seekers.cli.install_agent.get_agent_path",
+                    side_effect=mock_get_agent_path,
+                ),
+                patch(
+                    "sys.argv",
+                    [
+                        "install_agent.py",
+                        str(self.skill_dir),
+                        "--agent",
+                        "claude",
+                        "--dry-run",
+                    ],
+                ),
            ):
                exit_code = main()

                assert exit_code == 0
                # Directory should NOT be created
-                assert not (Path(agent_tmpdir) / ".claude" / "skills" / "test-skill").exists()
+                assert not (
+                    Path(agent_tmpdir) / ".claude" / "skills" / "test-skill"
+                ).exists()

    def test_cli_integration(self):
        """Test end-to-end CLI execution."""
@@ -447,11 +496,21 @@ class TestInstallAgentCLI:
            def mock_get_agent_path(agent_name, _project_root=None):
                return Path(agent_tmpdir) / f".{agent_name}" / "skills"

-            with patch(
-                "skill_seekers.cli.install_agent.get_agent_path", side_effect=mock_get_agent_path
-            ), patch(
-                "sys.argv",
-                ["install_agent.py", str(self.skill_dir), "--agent", "claude", "--force"],
+            with (
+                patch(
+                    "skill_seekers.cli.install_agent.get_agent_path",
+                    side_effect=mock_get_agent_path,
+                ),
+                patch(
+                    "sys.argv",
+                    [
+                        "install_agent.py",
+                        str(self.skill_dir),
+                        "--agent",
+                        "claude",
+                        "--force",
+                    ],
+                ),
            ):
                exit_code = main()

@@ -468,11 +527,21 @@ class TestInstallAgentCLI:
            def mock_get_agent_path(agent_name, _project_root=None):
                return Path(agent_tmpdir) / f".{agent_name}" / "skills"

-            with patch(
-                "skill_seekers.cli.install_agent.get_agent_path", side_effect=mock_get_agent_path
-            ), patch(
-                "sys.argv",
-                ["install_agent.py", str(self.skill_dir), "--agent", "all", "--force"],
+            with (
+                patch(
+                    "skill_seekers.cli.install_agent.get_agent_path",
+                    side_effect=mock_get_agent_path,
+                ),
+                patch(
+                    "sys.argv",
+                    [
+                        "install_agent.py",
+                        str(self.skill_dir),
+                        "--agent",
+                        "all",
+                        "--force",
+                    ],
+                ),
            ):
                exit_code = main()

--- a/tests/test_issue_219_e2e.py
+++ b/tests/test_issue_219_e2e.py
@@ -50,7 +50,9 @@ class TestIssue219Problem1LargeFiles(unittest.TestCase):
        # Mock large CHANGELOG (1.4MB, encoding="none")
        mock_content = Mock()
        mock_content.type = "file"
-        mock_content.encoding = "none"  # This is what GitHub API returns for large files
+        mock_content.encoding = (
+            "none"  # This is what GitHub API returns for large files
+        )
        mock_content.size = 1388271
        mock_content.download_url = (
            "https://raw.githubusercontent.com/ccxt/ccxt/master/CHANGELOG.md"
@@ -73,13 +75,16 @@ class TestIssue219Problem1LargeFiles(unittest.TestCase):

                # VERIFY: download_url was called
                mock_requests.assert_called_once_with(
-                    "https://raw.githubusercontent.com/ccxt/ccxt/master/CHANGELOG.md", timeout=30
+                    "https://raw.githubusercontent.com/ccxt/ccxt/master/CHANGELOG.md",
+                    timeout=30,
                )

                # VERIFY: CHANGELOG was extracted successfully
                self.assertIn("changelog", scraper.extracted_data)
                self.assertIn("Bug fixes", scraper.extracted_data["changelog"])
-                self.assertEqual(scraper.extracted_data["changelog"], mock_response.text)
+                self.assertEqual(
+                    scraper.extracted_data["changelog"], mock_response.text
+                )

    def test_large_file_fallback_on_error(self):
        """E2E: Verify graceful handling if download_url fails"""
@@ -179,7 +184,8 @@ class TestIssue219Problem2CLIFlags(unittest.TestCase):
            # VERIFY: sys.argv contains --enhance-local flag
            # (main.py should have added it before calling github_scraper)
            called_with_enhance = any(
-                "--enhance-local" in str(call) for call in mock_github_main.call_args_list
+                "--enhance-local" in str(call)
+                for call in mock_github_main.call_args_list
            )
            self.assertTrue(
                called_with_enhance or "--enhance-local" in sys.argv,
@@ -220,9 +226,12 @@ class TestIssue219Problem3CustomAPIEndpoints(unittest.TestCase):

        with (
            patch.dict(
-                os.environ, {"ANTHROPIC_API_KEY": "test-key-123", "ANTHROPIC_BASE_URL": custom_url}
+                os.environ,
+                {"ANTHROPIC_API_KEY": "test-key-123", "ANTHROPIC_BASE_URL": custom_url},
            ),
-            patch("skill_seekers.cli.enhance_skill.anthropic.Anthropic") as mock_anthropic,
+            patch(
+                "skill_seekers.cli.enhance_skill.anthropic.Anthropic"
+            ) as mock_anthropic,
        ):
            # Create enhancer
            _enhancer = SkillEnhancer(self.skill_dir)
@@ -249,7 +258,9 @@ class TestIssue219Problem3CustomAPIEndpoints(unittest.TestCase):
        # Use ANTHROPIC_AUTH_TOKEN instead of ANTHROPIC_API_KEY
        with (
            patch.dict(os.environ, {"ANTHROPIC_AUTH_TOKEN": custom_token}, clear=True),
-            patch("skill_seekers.cli.enhance_skill.anthropic.Anthropic") as mock_anthropic,
+            patch(
+                "skill_seekers.cli.enhance_skill.anthropic.Anthropic"
+            ) as mock_anthropic,
        ):
            # Create enhancer (should accept ANTHROPIC_AUTH_TOKEN)
            enhancer = SkillEnhancer(self.skill_dir)
@@ -265,7 +276,9 @@ class TestIssue219Problem3CustomAPIEndpoints(unittest.TestCase):
            mock_anthropic.assert_called_once()
            call_kwargs = mock_anthropic.call_args[1]
            self.assertEqual(
-                call_kwargs["api_key"], custom_token, "api_key should match ANTHROPIC_AUTH_TOKEN"
+                call_kwargs["api_key"],
+                custom_token,
+                "api_key should match ANTHROPIC_AUTH_TOKEN",
            )

    def test_thinking_block_handling(self):
@@ -275,7 +288,12 @@ class TestIssue219Problem3CustomAPIEndpoints(unittest.TestCase):
        except ImportError:
            self.skipTest("anthropic package not installed")

-        with patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}), patch("skill_seekers.cli.enhance_skill.anthropic.Anthropic") as mock_anthropic:
+        with (
+            patch.dict(os.environ, {"ANTHROPIC_API_KEY": "test-key"}),
+            patch(
+                "skill_seekers.cli.enhance_skill.anthropic.Anthropic"
+            ) as mock_anthropic,
+        ):
            enhancer = SkillEnhancer(self.skill_dir)

            # Mock response with ThinkingBlock (newer SDK)
@@ -283,7 +301,9 @@ class TestIssue219Problem3CustomAPIEndpoints(unittest.TestCase):
            mock_thinking_block = SimpleNamespace(type="thinking")

            # TextBlock has .text attribute
-            mock_text_block = SimpleNamespace(text="# Enhanced SKILL.md\n\nContent here")
+            mock_text_block = SimpleNamespace(
+                text="# Enhanced SKILL.md\n\nContent here"
+            )

            mock_message = Mock()
            mock_message.content = [mock_thinking_block, mock_text_block]
--- a/tests/test_llms_txt_downloader.py
+++ b/tests/test_llms_txt_downloader.py
@@ -30,7 +30,12 @@ def test_timeout_with_retry():
    """Test timeout scenario with retry logic"""
    downloader = LlmsTxtDownloader("https://example.com/llms.txt", max_retries=2)

-    with patch("requests.get", side_effect=requests.Timeout("Connection timeout")) as mock_get, patch("time.sleep") as mock_sleep:  # Mock sleep to speed up test
+    with (
+        patch(
+            "requests.get", side_effect=requests.Timeout("Connection timeout")
+        ) as mock_get,
+        patch("time.sleep") as mock_sleep,
+    ):  # Mock sleep to speed up test
        content = downloader.download()

    assert content is None
@@ -73,7 +78,10 @@ def test_http_error_handling():
    mock_response = Mock()
    mock_response.raise_for_status.side_effect = requests.HTTPError("404 Not Found")

-    with patch("requests.get", return_value=mock_response) as mock_get, patch("time.sleep"):
+    with (
+        patch("requests.get", return_value=mock_response) as mock_get,
+        patch("time.sleep"),
+    ):
        content = downloader.download()

    assert content is None
@@ -84,7 +92,10 @@ def test_exponential_backoff():
    """Test that exponential backoff delays are correct"""
    downloader = LlmsTxtDownloader("https://example.com/llms.txt", max_retries=3)

-    with patch("requests.get", side_effect=requests.Timeout("Connection timeout")), patch("time.sleep") as mock_sleep:
+    with (
+        patch("requests.get", side_effect=requests.Timeout("Connection timeout")),
+        patch("time.sleep") as mock_sleep,
+    ):
        content = downloader.download()

    assert content is None
@@ -132,7 +143,9 @@ def test_custom_max_retries():
    downloader = LlmsTxtDownloader("https://example.com/llms.txt", max_retries=5)

    with (
-        patch("requests.get", side_effect=requests.Timeout("Connection timeout")) as mock_get,
+        patch(
+            "requests.get", side_effect=requests.Timeout("Connection timeout")
+        ) as mock_get,
        patch("time.sleep"),
    ):
        content = downloader.download()
@@ -190,9 +203,7 @@ def test_is_markdown_rejects_html_doctype():
    """Test that HTML with DOCTYPE is rejected (prevents redirect trap)"""
    downloader = LlmsTxtDownloader("https://example.com/llms.txt")

-    html = (
-        "<!DOCTYPE html><html><head><title>Product Page</title></head><body>Content</body></html>"
-    )
+    html = "<!DOCTYPE html><html><head><title>Product Page</title></head><body>Content</body></html>"
    assert not downloader._is_markdown(html)

    # Test case-insensitive
@@ -219,7 +230,9 @@ def test_is_markdown_rejects_html_meta():
    html_with_head = "<head><title>Page</title></head><body>Content</body>"
    assert not downloader._is_markdown(html_with_head)

-    html_with_meta = '<meta charset="utf-8"><meta name="viewport" content="width=device-width">'
+    html_with_meta = (
+        '<meta charset="utf-8"><meta name="viewport" content="width=device-width">'
+    )
    assert not downloader._is_markdown(html_with_meta)


@@ -231,7 +244,9 @@ def test_is_markdown_accepts_markdown_with_html_words():
    assert downloader._is_markdown(markdown)

    # Test with actual markdown patterns
-    markdown_with_code = "# HTML Tutorial\n\n```html\n<div>example</div>\n```\n\n## More content"
+    markdown_with_code = (
+        "# HTML Tutorial\n\n```html\n<div>example</div>\n```\n\n## More content"
+    )
    assert downloader._is_markdown(markdown_with_code)


@@ -240,7 +255,9 @@ def test_html_detection_only_scans_first_500_chars():
    downloader = LlmsTxtDownloader("https://example.com/llms.txt")

    # HTML tag after 500 chars should not be detected
-    safe_markdown = "# Header\n\n" + ("Valid markdown content. " * 50) + "\n\n<!DOCTYPE html>"
+    safe_markdown = (
+        "# Header\n\n" + ("Valid markdown content. " * 50) + "\n\n<!DOCTYPE html>"
+    )
    # This should pass because <!DOCTYPE html> is beyond first 500 chars
    if len(safe_markdown[:500]) < len("<!DOCTYPE html>"):
        # If the HTML is within 500 chars, adjust test
@@ -277,7 +294,9 @@ def test_download_rejects_html_redirect():

    mock_response = Mock()
    # Simulate server returning HTML instead of markdown
-    mock_response.text = "<!DOCTYPE html><html><body><h1>Product Page</h1></body></html>"
+    mock_response.text = (
+        "<!DOCTYPE html><html><body><h1>Product Page</h1></body></html>"
+    )
    mock_response.raise_for_status = Mock()

    with patch("requests.get", return_value=mock_response):
--- a/tests/test_skip_llms_txt.py
+++ b/tests/test_skip_llms_txt.py
@@ -72,7 +72,13 @@ class TestSkipLlmsTxtSyncBehavior(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=False)

-                with patch.object(converter, "_try_llms_txt", return_value=False) as mock_try, patch.object(converter, "scrape_page"), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(
+                        converter, "_try_llms_txt", return_value=False
+                    ) as mock_try,
+                    patch.object(converter, "scrape_page"),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    mock_try.assert_called_once()
            finally:
@@ -93,7 +99,11 @@ class TestSkipLlmsTxtSyncBehavior(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=False)

-                with patch.object(converter, "_try_llms_txt") as mock_try, patch.object(converter, "scrape_page"), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(converter, "_try_llms_txt") as mock_try,
+                    patch.object(converter, "scrape_page"),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    mock_try.assert_not_called()
            finally:
@@ -114,7 +124,10 @@ class TestSkipLlmsTxtSyncBehavior(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=True)

-                with patch.object(converter, "_try_llms_txt") as mock_try, patch.object(converter, "save_summary"):
+                with (
+                    patch.object(converter, "_try_llms_txt") as mock_try,
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    mock_try.assert_not_called()
            finally:
@@ -140,7 +153,13 @@ class TestSkipLlmsTxtAsyncBehavior(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=False)

-                with patch.object(converter, "_try_llms_txt", return_value=False) as mock_try, patch.object(converter, "scrape_page_async", return_value=None), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(
+                        converter, "_try_llms_txt", return_value=False
+                    ) as mock_try,
+                    patch.object(converter, "scrape_page_async", return_value=None),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    mock_try.assert_called_once()
            finally:
@@ -162,7 +181,11 @@ class TestSkipLlmsTxtAsyncBehavior(unittest.TestCase):
                os.chdir(tmpdir)
                converter = DocToSkillConverter(config, dry_run=False)

-                with patch.object(converter, "_try_llms_txt") as mock_try, patch.object(converter, "scrape_page_async", return_value=None), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(converter, "_try_llms_txt") as mock_try,
+                    patch.object(converter, "scrape_page_async", return_value=None),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    mock_try.assert_not_called()
            finally:
@@ -179,7 +202,10 @@ class TestSkipLlmsTxtWithRealConfig(unittest.TestCase):
            "description": "Telegram bot documentation",
            "base_url": "https://core.telegram.org/bots",
            "skip_llms_txt": True,  # Telegram doesn't have useful llms.txt
-            "start_urls": ["https://core.telegram.org/bots", "https://core.telegram.org/bots/api"],
+            "start_urls": [
+                "https://core.telegram.org/bots",
+                "https://core.telegram.org/bots/api",
+            ],
            "selectors": {
                "main_content": "#dev_page_content, main, article",
                "title": "h1, title",
@@ -226,7 +252,9 @@ class TestSkipLlmsTxtEdgeCases(unittest.TestCase):
        with self.assertLogs("skill_seekers.cli.doc_scraper", level="WARNING") as cm:
            converter = DocToSkillConverter(config, dry_run=True)
            self.assertFalse(converter.skip_llms_txt)
-            self.assertTrue(any("Invalid value" in log and "0" in log for log in cm.output))
+            self.assertTrue(
+                any("Invalid value" in log and "0" in log for log in cm.output)
+            )

    def test_skip_llms_txt_with_int_one_logs_warning(self):
        """Test that integer 1 logs warning and defaults to False."""
@@ -240,7 +268,9 @@ class TestSkipLlmsTxtEdgeCases(unittest.TestCase):
        with self.assertLogs("skill_seekers.cli.doc_scraper", level="WARNING") as cm:
            converter = DocToSkillConverter(config, dry_run=True)
            self.assertFalse(converter.skip_llms_txt)
-            self.assertTrue(any("Invalid value" in log and "1" in log for log in cm.output))
+            self.assertTrue(
+                any("Invalid value" in log and "1" in log for log in cm.output)
+            )

    def test_skip_llms_txt_with_string_logs_warning(self):
        """Test that string values log warning and default to False."""
@@ -254,7 +284,9 @@ class TestSkipLlmsTxtEdgeCases(unittest.TestCase):
        with self.assertLogs("skill_seekers.cli.doc_scraper", level="WARNING") as cm:
            converter = DocToSkillConverter(config, dry_run=True)
            self.assertFalse(converter.skip_llms_txt)
-            self.assertTrue(any("Invalid value" in log and "true" in log for log in cm.output))
+            self.assertTrue(
+                any("Invalid value" in log and "true" in log for log in cm.output)
+            )

    def test_skip_llms_txt_with_none_logs_warning(self):
        """Test that None logs warning and defaults to False."""
@@ -268,7 +300,9 @@ class TestSkipLlmsTxtEdgeCases(unittest.TestCase):
        with self.assertLogs("skill_seekers.cli.doc_scraper", level="WARNING") as cm:
            converter = DocToSkillConverter(config, dry_run=True)
            self.assertFalse(converter.skip_llms_txt)
-            self.assertTrue(any("Invalid value" in log and "None" in log for log in cm.output))
+            self.assertTrue(
+                any("Invalid value" in log and "None" in log for log in cm.output)
+            )

    def test_scraping_proceeds_when_llms_txt_skipped(self):
        """Test that HTML scraping proceeds normally when llms.txt is skipped."""
@@ -292,7 +326,10 @@ class TestSkipLlmsTxtEdgeCases(unittest.TestCase):
                    scrape_called.append(url)
                    return None

-                with patch.object(converter, "scrape_page", side_effect=mock_scrape), patch.object(converter, "save_summary"):
+                with (
+                    patch.object(converter, "scrape_page", side_effect=mock_scrape),
+                    patch.object(converter, "save_summary"),
+                ):
                    converter.scrape_all()
                    # Should have attempted to scrape the base URL
                    self.assertTrue(len(scrape_called) > 0)