cowork-bot: fix import parsing for type-only and mixed default+named imports

Author: DevForge Engineer

src/deadcode/scanner.py

@@ -87,9 +87,9 @@ def unreferenced_components(self) -> list[Finding]:
     r"\.([a-zA-Z_][\w-]*(?::[\w-]+)*)\s*(?:\{|,|\[)",
 )
 
-# import statements
+# import statements (handles default, named, type-only, and mixed forms)
 _IMPORT_PATTERN = re.compile(
-    r"import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['\"]([^'\"]+)['\"]",
+    r"import\s+(?:type\s+)?(?:(\w+))?\s*,?\s*(?:\{([^}]+)\})?\s*from\s+['\"]([^'\"]+)['\"]",
 )
 
 # className="..." or className={...} in JSX
@@ -300,18 +300,26 @@ def _parse_exports(
     def _parse_imports(
         self, content: str, rel_path: str, imports: dict[str, set[str]]
     ) -> None:
-        """Extract import names from a file."""
+        """Extract import names from a file.
+
+        Handles default, named, type-only, and mixed import forms:
+            import Foo from '...'
+            import { Foo, Bar } from '...'
+            import type { Foo } from '...'
+            import Foo, { Bar } from '...'
+        """
         for m in _IMPORT_PATTERN.finditer(content):
-            # Named imports: import { Foo, Bar } from '...'
-            if m.group(1):
-                names = [n.strip().split(" as ")[0].strip() for n in m.group(1).split(",")]
+            default_import = m.group(1)
+            named_imports = m.group(2)
+            module_path = m.group(3)
+
+            if default_import:
+                imports.setdefault(default_import, set()).add(rel_path)
+            if named_imports:
+                names = [n.strip().split(" as ")[0].strip() for n in named_imports.split(",")]
                 for name in names:
                     if name:
                         imports.setdefault(name, set()).add(rel_path)
-            # Default import: import Foo from '...'
-            elif m.group(2):
-                name = m.group(2)
-                imports.setdefault(name, set()).add(rel_path)
 
     def _parse_css_classes(
         self, content: str, rel_path: str, css_classes: dict[str, list[tuple[str, int]]]

tests/test_scanner.py

@@ -185,6 +185,33 @@ def test_used_exports_not_reported(self, tmp_path):
         unused_names = {f.name for f in result.unused_exports}
         assert "myFunc" not in unused_names
 
+    def test_type_import_counts_as_used(self, tmp_path):
+        """import type { Foo } should mark Foo as used."""
+        mod = tmp_path / "mod.ts"
+        mod.write_text('export type Foo = string;\n')
+        app = tmp_path / "app.ts"
+        app.write_text('import type { Foo } from "./mod";\nconst x: Foo = "hello";\n')
+
+        scanner = DeadCodeScanner(tmp_path)
+        result = scanner.scan()
+
+        unused_names = {f.name for f in result.unused_exports}
+        assert "Foo" not in unused_names
+
+    def test_mixed_default_and_named_import_counts_as_used(self, tmp_path):
+        """import默认 + named should mark both as used."""
+        mod = tmp_path / "mod.ts"
+        mod.write_text('export function myFunc() { return 1; }\n')
+        app = tmp_path / "app.ts"
+        app.write_text('import Default, { myFunc } from "./mod";\nmyFunc();\n')
+
+        scanner = DeadCodeScanner(tmp_path)
+        result = scanner.scan()
+
+        unused_names = {f.name for f in result.unused_exports}
+        assert "myFunc" not in unused_names
+        assert "Default" not in unused_names
+
 
 class TestCSSParsing:
     def test_orphaned_css_detection(self, tmp_path):