ListSideEffects

Name: ListSideEffects
Availability: InStock
Author: fnoritomi

Detect module-level side effects in JavaScript/TypeScript projects during import.

Updated Aug 23, 2026

Search Tags:#typescript #testing #refactoring #static-analysis #side-effects #module-import

Ready to run

npx skills add https://github.com/fnoritomi/tabulador-dados-abertos --skill listsideeffects

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: ListSideEffects
Source: https://github.com/fnoritomi/tabulador-dados-abertos/tree/main/.agent/skills/list-side-effects
Command: npx skills add https://github.com/fnoritomi/tabulador-dados-abertos --skill listsideeffects

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers identify and catalog side effects that execute at module import time, enabling safer testing, easier refactoring, and more predictable code.

Core Features & Use Cases

Detect immediate top-level function calls, global object access, I/O operations, and initialization patterns that run when a module is loaded.
Classify findings by type and risk to prioritize fixes.
Produce context-rich reports showing lines around each finding and suggested remediation.
Integrate into CI/dev workflows to prevent regressions during refactors or rewrites.

Quick Start

Run the ListSideEffects analysis on your TypeScript project to generate a side-effects report for all modules.

Frequently Asked Questions about ListSideEffects

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I detect module-level side effects executing during import in TypeScript?▼

To detect module-level side effects in TypeScript, you can use static analysis pattern scanning to identify top-level initialization, global mutations, and I/O operations that execute when a module is loaded. This produces a structured report classifying findings by type and risk for remediation.

Why do module-level side effects hinder testing and refactoring in JavaScript projects?▼

Module-level side effects hinder testing and refactoring because top-level initialization and global mutations execute upon import, creating unpredictable state and I/O dependencies. This makes modules harder to isolate in tests and riskier to rewrite or refactor without introducing regressions.

What is the best way to find top-level initialization and global mutations in my codebase?▼

The best way to find top-level initialization and global mutations is pattern-based static analysis, which scans for immediate function calls, global object access, and module-state mutations at import time, then outputs a context-rich report to prioritize fixes.

Can I integrate side effect detection into my CI pipeline to prevent refactoring regressions?▼

Yes, you can integrate side effect detection into CI and dev workflows to prevent regressions during refactors or rewrites. Scanning modules for import-time side effects produces a structured report that helps enforce safer testing and code predictability.

Does this static analysis tool work with JavaScript projects or only TypeScript?▼

This static analysis targets both JavaScript and TypeScript projects. It identifies immediate function calls, global access, I/O operations, and module-state mutations at the module scope to produce context-rich reports for safer testing.

How are detected module import side effects classified for remediation?▼

Detected module import side effects are classified by type and risk level to help prioritize fixes. The tool generates a structured remediation report containing the classification alongside context lines showing exactly where each side effect occurs.