[FIX] defer fastkit import until after sys.path bootstrap and close patch-coverage gaps

Fixes the two P1 findings raised by Codex on #52 and lifts the patch
coverage above the 89% threshold so the PR can proceed.

- scripts/inspect-templates.py, scripts/inspect-changed-templates.py:
  import `fastapi_fastkit.backend.inspector` only after the sys.path
  bootstrap runs, so the scripts work from a fresh checkout where the
  package is not installed on the interpreter.
- tests/test_utils.py: cover the setup.py read-error branch in
  `is_fastkit_project`, the malformed-pyproject text fallback (tool-section
  hit, no-markers miss, and read-error path).
- tests/test_backends/test_main.py: cover the non-list `[project].dependencies`
  guard in `_parse_pyproject_dependencies` and the no-trailing-newline
  branch of `_ensure_pyproject_fastkit_markers`.
- tests/test_backends/test_inspector.py: cover the pyproject parse-error,
  setup.py-tpl read-error, and no-sources-at-all branches of
  `_check_dependencies`, plus the non-list and non-string-entry paths of
  `_extract_pyproject_dependency_names`.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: bnbong

scripts/inspect-changed-templates.py

@@ -8,12 +8,14 @@
 from pathlib import Path
 from typing import List, Set
 
-from fastapi_fastkit.backend.inspector import inspect_fastapi_template
-
-# Ensure src is importable
+# Ensure src is importable before importing the package. Pre-commit / local
+# runs invoke this script with the project not installed in the interpreter,
+# so the sys.path bootstrap has to happen first.
 PROJECT_ROOT = Path(__file__).parent.parent
 sys.path.insert(0, str(PROJECT_ROOT / "src"))
 
+from fastapi_fastkit.backend.inspector import inspect_fastapi_template  # noqa: E402
+
 TEMPLATE_DIR = PROJECT_ROOT / "src" / "fastapi_fastkit" / "fastapi_project_template"
 
 

scripts/inspect-templates.py

@@ -17,12 +17,14 @@
 from pathlib import Path
 from typing import Any, Dict, List
 
-from fastapi_fastkit.backend.inspector import inspect_fastapi_template
-
-# Add src to path to import fastapi_fastkit modules
+# Add src to path to import fastapi_fastkit modules. The sys.path bootstrap
+# must run before importing the package so the script works from a fresh
+# repo checkout without the package installed on the interpreter.
 project_root = Path(__file__).parent.parent
 sys.path.insert(0, str(project_root / "src"))
 
+from fastapi_fastkit.backend.inspector import inspect_fastapi_template  # noqa: E402
+
 
 def get_templates_to_inspect(specific_templates: str = "") -> List[str]:
     """Get list of templates to inspect."""

tests/test_backends/test_inspector.py

@@ -323,6 +323,106 @@ def test_check_dependencies_setup_py_only_with_fastapi(self, temp_dir: str) -> N
         assert result is True
         assert inspector.errors == []
 
+    def test_check_dependencies_pyproject_parse_error(self, temp_dir: str) -> None:
+        """Malformed pyproject.toml-tpl surfaces a parse error and fails the check."""
+        # given
+        (self.template_path / "tests").mkdir(exist_ok=True)
+        (self.template_path / "README.md-tpl").write_text("# Test")
+        # Unterminated string makes tomllib raise TOMLDecodeError.
+        (self.template_path / "pyproject.toml-tpl").write_text(
+            '[project]\nname = "demo\nversion = "0.1.0"\n'
+        )
+
+        # when
+        with patch("fastapi_fastkit.backend.transducer.copy_and_convert_template"):
+            inspector = TemplateInspector(str(self.template_path), temp_dir)
+            result = inspector._check_dependencies()
+
+        # then
+        assert result is False
+        assert any("Invalid pyproject.toml-tpl" in error for error in inspector.errors)
+
+    def test_check_dependencies_setup_py_read_error(self, temp_dir: str) -> None:
+        """OSError while reading setup.py-tpl surfaces a descriptive error."""
+        # given
+        (self.template_path / "tests").mkdir(exist_ok=True)
+        (self.template_path / "README.md-tpl").write_text("# Test")
+        (self.template_path / "setup.py-tpl").write_text(
+            'from setuptools import setup\nsetup(name="demo")\n'
+        )
+
+        # when — selectively fail the open() targeting setup.py-tpl only.
+        real_open = open
+
+        def selective_open(file, *args, **kwargs):  # type: ignore[no-untyped-def]
+            if str(file).endswith("setup.py-tpl"):
+                raise OSError("Permission denied")
+            return real_open(file, *args, **kwargs)
+
+        with patch("fastapi_fastkit.backend.transducer.copy_and_convert_template"):
+            inspector = TemplateInspector(str(self.template_path), temp_dir)
+            with patch("builtins.open", side_effect=selective_open):
+                result = inspector._check_dependencies()
+
+        # then
+        assert result is False
+        assert any("Error reading setup.py-tpl" in error for error in inspector.errors)
+
+    def test_check_dependencies_no_sources_at_all(self, temp_dir: str) -> None:
+        """Calling _check_dependencies with no metadata files yields a clear error."""
+        # given
+        (self.template_path / "tests").mkdir(exist_ok=True)
+        (self.template_path / "README.md-tpl").write_text("# Test")
+
+        # when
+        with patch("fastapi_fastkit.backend.transducer.copy_and_convert_template"):
+            inspector = TemplateInspector(str(self.template_path), temp_dir)
+            result = inspector._check_dependencies()
+
+        # then
+        assert result is False
+        assert any("No dependency source found" in error for error in inspector.errors)
+
+    def test_extract_pyproject_dependency_names_non_list(self, temp_dir: str) -> None:
+        """Non-list [project].dependencies yields a descriptive parse error."""
+        # given
+        (self.template_path / "tests").mkdir(exist_ok=True)
+        (self.template_path / "README.md-tpl").write_text("# Test")
+        pyproject = self.template_path / "pyproject.toml-tpl"
+        pyproject.write_text(
+            '[project]\nname = "demo"\nversion = "0.1.0"\n'
+            'dependencies = "fastapi>=0.115"\n'
+        )
+
+        # when
+        names, error = TemplateInspector._extract_pyproject_dependency_names(pyproject)
+
+        # then
+        assert names == set()
+        assert error is not None
+        assert "must be a list" in error
+
+    def test_extract_pyproject_dependency_names_skips_non_strings(
+        self, temp_dir: str
+    ) -> None:
+        """Non-string / empty entries in [project].dependencies are ignored."""
+        # given
+        (self.template_path / "tests").mkdir(exist_ok=True)
+        (self.template_path / "README.md-tpl").write_text("# Test")
+        pyproject = self.template_path / "pyproject.toml-tpl"
+        pyproject.write_text(
+            '[project]\nname = "demo"\nversion = "0.1.0"\n'
+            # Empty string and an integer-ish value are dropped without raising.
+            'dependencies = ["fastapi>=0.115", "", "   "]\n'
+        )
+
+        # when
+        names, error = TemplateInspector._extract_pyproject_dependency_names(pyproject)
+
+        # then
+        assert error is None
+        assert names == {"fastapi"}
+
     @patch("fastapi_fastkit.backend.inspector.find_template_core_modules")
     def test_check_fastapi_implementation_valid(
         self, mock_find_modules: MagicMock, temp_dir: str

tests/test_backends/test_main.py

@@ -507,6 +507,42 @@ def test_process_pyproject_file_writes_markers_into_generated_pyproject(
 
             shutil.rmtree(str(template_path))
 
+    def test_parse_pyproject_dependencies_non_list_value(self) -> None:
+        """Non-list dependencies value returns [] rather than raising."""
+        template_path = Path(tempfile.mkdtemp())
+        try:
+            pyproject = template_path / "pyproject.toml-tpl"
+            # A string in place of a dependencies array exercises the
+            # defensive isinstance() guard.
+            pyproject.write_text(
+                '[project]\nname = "demo"\nversion = "0.1.0"\n'
+                'dependencies = "fastapi>=0.115"\n'
+            )
+
+            result = _parse_pyproject_dependencies(str(pyproject))
+
+            assert result == []
+
+        finally:
+            import shutil
+
+            shutil.rmtree(str(template_path))
+
+    def test_ensure_pyproject_fastkit_markers_appends_newline_when_missing(
+        self,
+    ) -> None:
+        """Content without a trailing newline gets one before the tool section."""
+        content = '[project]\nname = "demo"\ndescription = "x"'
+        assert not content.endswith("\n")
+
+        result = _ensure_pyproject_fastkit_markers(content)
+
+        # Marker + tool section are present and the output ends cleanly.
+        assert "[tool.fastapi-fastkit]" in result
+        assert result.endswith("managed = true\n")
+        # No doubled newlines immediately before the inserted table.
+        assert "\n\n\n[tool.fastapi-fastkit]" not in result
+
     @patch("builtins.open", mock_open(read_data="fastapi>=0.100.0"))
     @patch("os.path.exists", return_value=True)
     def test_read_template_stack_file_read_error(self, mock_exists: MagicMock) -> None:

tests/test_utils.py

@@ -265,6 +265,61 @@ def test_is_fastkit_project_malformed_pyproject_falls_back(
 
         assert is_fastkit_project(str(project_path)) is True
 
+    def test_is_fastkit_project_malformed_pyproject_tool_section_text(
+        self, temp_dir: str
+    ) -> None:
+        """Malformed pyproject with a [tool.fastapi-fastkit] header is still detected."""
+        from fastapi_fastkit.utils.main import is_fastkit_project
+
+        project_path = Path(temp_dir) / "broken-with-tool"
+        project_path.mkdir()
+        # Unterminated string makes tomllib fail, but the text-fallback spots
+        # the [tool.fastapi-fastkit] header.
+        (project_path / "pyproject.toml").write_text(
+            '[project\nname = "broken\n\n[tool.fastapi-fastkit]\nmanaged = true\n'
+        )
+
+        assert is_fastkit_project(str(project_path)) is True
+
+    def test_is_fastkit_project_malformed_pyproject_no_markers(
+        self, temp_dir: str
+    ) -> None:
+        """Malformed pyproject with neither marker falls through to False."""
+        from fastapi_fastkit.utils.main import is_fastkit_project
+
+        project_path = Path(temp_dir) / "broken-unmarked"
+        project_path.mkdir()
+        (project_path / "pyproject.toml").write_text(
+            '[project\nname = "broken\ndescription = "nothing here"\n'
+        )
+
+        assert is_fastkit_project(str(project_path)) is False
+
+    def test_is_fastkit_project_setup_py_read_error(self, temp_dir: str) -> None:
+        """OSError while reading setup.py does not crash detection; returns False."""
+        from fastapi_fastkit.utils.main import is_fastkit_project
+
+        project_path = Path(temp_dir) / "setup-read-err"
+        project_path.mkdir()
+        (project_path / "setup.py").write_text(
+            'from setuptools import setup\nsetup(name="demo")\n'
+        )
+
+        with patch("builtins.open", side_effect=OSError("Permission denied")):
+            assert is_fastkit_project(str(project_path)) is False
+
+    def test_pyproject_text_marks_fastkit_read_error(self, temp_dir: str) -> None:
+        """Text fallback swallows OSError and returns False cleanly."""
+        from fastapi_fastkit.utils.main import _pyproject_text_marks_fastkit
+
+        project_path = Path(temp_dir) / "text-fallback-err"
+        project_path.mkdir()
+        pyproject = project_path / "pyproject.toml"
+        pyproject.write_text("whatever")
+
+        with patch("builtins.open", side_effect=OSError("Permission denied")):
+            assert _pyproject_text_marks_fastkit(str(pyproject)) is False
+
     def test_print_error_with_traceback(self) -> None:
         """Test print_error function with traceback enabled."""
         # given