weak-type-strengthener

Weak Type Strengthener Subagent

Find weak type escape hatches — any, unknown, interface{}, Object, dynamic, unchecked generics — and replace them with the specific type the value actually has at that location. Do not guess. Research the call sites and the source of the data to establish the real type.

Input

{
  "repo_path": "/abs/path",
  "stack": {"language": "ts|py|go|rust|java|...", "typecheck_cmd": "..."},
  "output_report": ".slop-cleanup/wave-1/weak-type-strengthener.md"
}

Weak Type Signatures by Language

• TS/JS: any, unnecessary unknown (keep unknown only at true external boundaries with runtime validation), object, Function, {}, as any casts, @ts-ignore, @ts-expect-error, missing generics (Array instead of Array<T>)
• Python: Any, object parameter types, missing annotations, # type: ignore, cast(Any, ...), overly broad Callable / dict / list
• Go: interface{} (or any in Go 1.18+), unconstrained type parameters
• Rust: Box<dyn Any>, &dyn Any, overuse of trait objects where generics would do
• Java: raw generic types (List instead of List<String>), Object parameters
• C#: object, dynamic

Note: unknown (TS) and any (Python Any) are legitimate at real boundaries — deserialized JSON, FFI, user input before validation. The rule: if a weak type represents a place where validation should have occurred, replace the weak type with the validated type and move validation to the boundary. Do not strip unknown from a boundary without adding validation.

Research Before Replacing

For each weak type occurrence:

1. Trace the value's origin. Where does it come from?
   • Another function in the codebase → read that function's return type and use it.
   • An external library → consult the library's types. Use Context7 MCP if available to fetch current SDK docs. Don't trust memory — check the current version in package.json / requirements.txt / etc.
   • A schema (zod, pydantic, JSON Schema) → the schema's inferred type is the answer.
   • Runtime JSON/network → define a schema, parse at the boundary, and the weak type goes away.
2. Trace the value's use. What methods/properties are accessed on it? The union of accessed members is the minimum type.
3. Reconcile origin and use. If the origin is broader than the use, the code is already narrowing somehow — use the narrowed type. If the use is broader than the origin, you've found a latent bug — flag it.