Add NPM.TypesCompanion module (suggest, types_package, has_own_types?, orphaned_types) with 11 tests for @types/* companion package suggestions\n\nResult: {"status":"keep","test_count":2697}

Author: dannote

autoresearch.jsonl

@@ -249,3 +249,4 @@
 {"run":248,"commit":"a549720","metric":2653,"metrics":{},"status":"keep","description":"Add NPM.ProjectInit module (initialized?, create_package_json, checklist, ready?, format_checklist) with 9 tests for npm project scaffolding and setup verification","timestamp":1773420228096,"segment":0}
 {"run":249,"commit":"d70e035","metric":2665,"metrics":{},"status":"keep","description":"Add NPM.ErrorMessage module (format, suggestion, retryable?) with 12 tests for structured error formatting with actionable suggestions","timestamp":1773420275238,"segment":0}
 {"run":250,"commit":"fe47c8b","metric":2675,"metrics":{},"status":"keep","description":"Add NPM.ProgressReporter module (resolving, fetching, linking, done, breakdown, format_time) with 10 tests for install progress output","timestamp":1773420336116,"segment":0}
+{"run":251,"commit":"bb58203","metric":2686,"metrics":{},"status":"keep","description":"Add NPM.CacheStats module (hit_miss, hit_rate, disk_size, list_cached, format, format_size) with 11 tests for cache usage statistics and metrics","timestamp":1773420393329,"segment":0}

lib/npm/types_companion.ex

@@ -0,0 +1,81 @@
+defmodule NPM.TypesCompanion do
+  @moduledoc """
+  Suggests @types/* companion packages for dependencies that need TypeScript type definitions.
+  """
+
+  @bundled_types ~w(typescript @types/node)
+  @has_own_types ~w(axios zod prisma date-fns)
+
+  @doc """
+  Suggests @types/* packages for dependencies that likely need them.
+  """
+  @spec suggest(map()) :: [%{package: String.t(), types_package: String.t()}]
+  def suggest(pkg_data) do
+    deps = Map.get(pkg_data, "dependencies", %{})
+    dev_deps = Map.get(pkg_data, "devDependencies", %{})
+    all_installed = Map.merge(deps, dev_deps) |> Map.keys() |> MapSet.new()
+
+    own_types = MapSet.new(@has_own_types)
+
+    deps
+    |> Map.keys()
+    |> Enum.reject(fn name -> scoped?(name) or MapSet.member?(own_types, name) end)
+    |> Enum.map(fn name -> {name, types_package(name)} end)
+    |> Enum.reject(fn {_, types} -> MapSet.member?(all_installed, types) end)
+    |> Enum.map(fn {name, types} -> %{package: name, types_package: types} end)
+    |> Enum.sort_by(& &1.package)
+  end
+
+  @doc """
+  Returns the @types/* package name for a given package.
+  """
+  @spec types_package(String.t()) :: String.t()
+  def types_package("@" <> _ = scoped) do
+    name = scoped |> String.replace("/", "__") |> String.trim_leading("@")
+    "@types/#{name}"
+  end
+
+  def types_package(name), do: "@types/#{name}"
+
+  @doc """
+  Checks if a package typically ships its own types.
+  """
+  @spec has_own_types?(map()) :: boolean()
+  def has_own_types?(pkg_data) do
+    Map.has_key?(pkg_data, "types") or
+      Map.has_key?(pkg_data, "typings") or
+      Map.get(pkg_data, "name", "") in @has_own_types
+  end
+
+  @doc """
+  Returns packages that are @types/* but whose companion is not installed.
+  """
+  @spec orphaned_types(map()) :: [String.t()]
+  def orphaned_types(pkg_data) do
+    all_deps =
+      Map.merge(
+        Map.get(pkg_data, "dependencies", %{}),
+        Map.get(pkg_data, "devDependencies", %{})
+      )
+
+    all_keys = Map.keys(all_deps) |> MapSet.new()
+
+    all_keys
+    |> Enum.filter(&String.starts_with?(&1, "@types/"))
+    |> Enum.reject(fn types_pkg ->
+      companion = types_pkg |> String.trim_leading("@types/") |> String.replace("__", "/")
+      companion = if String.contains?(companion, "/"), do: "@#{companion}", else: companion
+      MapSet.member?(all_keys, companion)
+    end)
+    |> Enum.sort()
+  end
+
+  @doc """
+  Returns bundled types packages.
+  """
+  @spec bundled :: [String.t()]
+  def bundled, do: @bundled_types
+
+  defp scoped?("@" <> _), do: true
+  defp scoped?(_), do: false
+end

test/npm/types_companion_test.exs

@@ -0,0 +1,79 @@
+defmodule NPM.TypesCompanionTest do
+  use ExUnit.Case, async: true
+
+  describe "suggest" do
+    test "suggests types for untyped deps" do
+      data = %{"dependencies" => %{"express" => "^4.18", "lodash" => "^4.17"}}
+      suggestions = NPM.TypesCompanion.suggest(data)
+      names = Enum.map(suggestions, & &1.types_package)
+      assert "@types/express" in names
+      assert "@types/lodash" in names
+    end
+
+    test "skips already installed types" do
+      data = %{
+        "dependencies" => %{"express" => "^4.18"},
+        "devDependencies" => %{"@types/express" => "^4.17"}
+      }
+
+      suggestions = NPM.TypesCompanion.suggest(data)
+      refute Enum.any?(suggestions, &(&1.types_package == "@types/express"))
+    end
+
+    test "skips packages with own types" do
+      data = %{"dependencies" => %{"axios" => "^1.0"}}
+      suggestions = NPM.TypesCompanion.suggest(data)
+      refute Enum.any?(suggestions, &(&1.package == "axios"))
+    end
+
+    test "empty for no deps" do
+      assert [] = NPM.TypesCompanion.suggest(%{})
+    end
+  end
+
+  describe "types_package" do
+    test "regular package" do
+      assert "@types/lodash" = NPM.TypesCompanion.types_package("lodash")
+    end
+
+    test "scoped package" do
+      assert "@types/babel__core" = NPM.TypesCompanion.types_package("@babel/core")
+    end
+  end
+
+  describe "has_own_types?" do
+    test "true for types field" do
+      assert NPM.TypesCompanion.has_own_types?(%{"types" => "./index.d.ts"})
+    end
+
+    test "true for typings field" do
+      assert NPM.TypesCompanion.has_own_types?(%{"typings" => "./index.d.ts"})
+    end
+
+    test "false without types" do
+      refute NPM.TypesCompanion.has_own_types?(%{"name" => "express"})
+    end
+  end
+
+  describe "orphaned_types" do
+    test "detects orphaned @types packages" do
+      data = %{
+        "dependencies" => %{"react" => "^18.0"},
+        "devDependencies" => %{"@types/react" => "^18.0", "@types/lodash" => "^4.14"}
+      }
+
+      orphans = NPM.TypesCompanion.orphaned_types(data)
+      assert "@types/lodash" in orphans
+      refute "@types/react" in orphans
+    end
+
+    test "empty when all have companions" do
+      data = %{
+        "dependencies" => %{"react" => "^18.0"},
+        "devDependencies" => %{"@types/react" => "^18.0"}
+      }
+
+      assert [] = NPM.TypesCompanion.orphaned_types(data)
+    end
+  end
+end