impact-analysis
/impact-analysis
Analizuje, co się zepsuje po zmianie symbolu: znajduje wywołujących, grupuje według poziomu ryzyka i ocenia wpływ, przy pytaniach o zasięg zmiany i planowaniu refaktoryzacji.
- Autor
- anortham ↗
- Repozytorium
- julie ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 02.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 02.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Analizuje, co się zepsuje po zmianie symbolu: znajduje wywołujących, grupuje według poziomu ryzyka i ocenia wpływ, przy pytaniach o zasięg zmiany i planowaniu refaktoryzacji.
Oryginalny opis (EN)
Analyze what would break if a symbol changes: finds callers, groups by risk level, assesses impact. Use when the user asks about blast radius, who uses a symbol, or is planning a refactor.
Jak działa
- Process
- Important Notes
Podgląd SKILL.md
---
name: impact-analysis
description: "Analyze what would break if a symbol changes: finds callers, groups by risk level, assesses impact. Use when the user asks about blast radius, who uses a symbol, or is planning a refactor."
user-invocable: true
arguments: "<symbol, file path, or change target>"
allowed-tools: mcp__julie__fast_search, mcp__julie__fast_refs, mcp__julie__deep_dive, mcp__julie__get_context, mcp__julie__call_path, mcp__julie__blast_radius, mcp__julie__manage_workspace
---
# Impact Analysis
Analyze the impact of changing a symbol by finding all references and assessing risk. Use this BEFORE modifying widely-used symbols.
## Process
### Step 1: Resolve the change target
If the user gives you a symbol name, resolve the definition first so you know which file or symbol they mean:
```
fast_search(query="<symbol_name>", workspace="<workspace_id>")
deep_dive(symbol="<symbol_name>", context_file="<partial_file_path>", depth="overview", workspace="<workspace_id>")
```
Use `context_file` when the name is ambiguous. If the target is described conceptually rather than named exactly, try `fast_search(query="<concept>", backend="semantic", workspace="<workspace_id>")` or `backend="hybrid"` to find candidate symbols. Semantic/hybrid `fast_search` results are symbol-only; use explicit lexical for file paths and pure lexical comparison. Default `fast_search` may show labeled semantic fallback candidates only after an identifier-like unscoped lexical zero-hit. `blast_radius(symbol_ids=[...], workspace="<workspace_id>")` is the tightest seed mode, but only use it when another Julie result already gave you concrete symbol IDs. If all you have is a definition file, use `file_paths=[...]`.
### Step 2: One-shot impact via blast_radius
```
blast_radius(file_paths=["<definition_file>"], max_depth=2, include_tests=true, workspace="<workspace_id>")
```
`blast_radius` is the primary entry point for impact analysis. One call returns ranked impacted symbols with why-reasons and likely tests. It walks the reference graph deterministically, so you don't have to chain `get_context → fast_refs → deep_dive` to build the same picture.
You can seed it three ways:
- `file_paths=["src/foo.rs"]` — default when you know the changed file but not a symbol ID
- `symbol_ids=["<id>"]` — tighter impact when another Julie result already gave you concrete symbol IDs
If the impact list is large, the output ends with `Output truncated at <N> results; narrow the query or pass a smaller limit.` See Step 4.
### Step 3: Drill down into high-risk callers
For any impacted symbol you need to understand in depth (unfamiliar caller, ambiguous usage, high centrality), use the targeted tools:
```
fast_refs(symbol="<caller>", include_definition=true, limit=100, workspace="<workspace_id>")
deep_dive(symbol="<caller>", depth="context", workspace="<workspace_id>")
```
If `deep_dive` returns the wrong symbol (common names like `new`, `result`, `config`), use `context_file` to disambiguate:
```
deep_dive(symbol="<caller>", context_file="<partial_file_path>", workspace="<workspace_id>")
```
### Step 4: Narrow long impact lists
If Step 2 ended with the truncation line, rerun `blast_radius` with a larger `limit`, a smaller `max_depth`, or a tighter seed (`symbol_ids` instead of `file_paths`).
### Step 5: Sample Deep Dives on High-Risk Callers
For each high-risk file surfaced by `blast_radius`, `deep_dive` on the calling function to understand HOW the symbol is used:
- Is it called with specific arguments?
- Does the caller depend on the return type?
- Is it used in error handling paths?
If you need the shortest route from one surfaced caller into a downstream sink or shared dependency, use `call_path` after `blast_radius`:
```
call_path(from="<impacted_symbol>", to="<downstream_symbol>", workspace="<workspace_id>")
```
### Categorizing Callers by Risk
`blast_radius` gives you ranked impact with why-reasons, but you still want to sort callers into tiers for the final report:
**High Risk** — Changes here could cause cascading failures:
- Entry points and core orchestration files (e.g., main entry, request handlers, routers)
- Files with 10+ references to this symbol
- Files that re-export or wrap this symbol
**Medium Risk** — Changes need careful testing:
- Feature implementation files
- Data access / storage modules
- Files with 3-9 references
**Low Risk** — Changes are isolated:
- Test files (paths containing `test`, `tests`, `spec`, `__tests__`, or test annotations)
- Files with 1-2 references
### Step 6: Report
```
Impact Analysis: <change_target>
Definition: <file>:<line> (<kind>)
Centrality: <high/medium/low>
Total: <N> references across <M> files
High Risk (<count> files):
src/handler.rs — 15 refs
Callers: process_request, handle_error, validate_input
Usage: Core request pipeline, changes here affect all tool calls
src/database/queries.rs — 12 refs
Callers: fetch_symbols, update_index
Usage: Database layer, type changes would require migration
Medium Risk (<count> files):
src/tools/search.rs — 5 refs
src/tools/navigation.rs — 3 refs
Low Risk (<count> files):
src/tests/search_tests.rs — 8 refs (test code)
src/tests/handler_tests.rs — 2 refs (test code)
Likely Tests:
src/tests/handler_tests.rs::test_process_request
src/tests/integration/pipeline.rs::test_end_to_end
Recommendation:
<1-2 sentences on how to approach this change safely>
```
## Important Notes
- **Always check test coverage** — high-risk changes with no test references are especially dangerous. `blast_radius` surfaces likely tests via the `include_tests=true` flag, so use it.
- **Type changes cascade** — if the symbol is a type/struct, any field change affects all users
- **Interface/trait changes are widest** — changing an interface method, trait, or abstract class affects all implementors
- **Cross-workspace**: Call `manage_workspace(operation="open", path="<path>")` first, then pass the returned ID as `workspace` to scoped calls; use `workspace_id` only for management operations that require it.
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · anortham/julie | 100 | MIT |
| me-cedric/Shipyard | 100 | MIT |
| Mozurok/fhorja.dev | 100 | MIT |
| 0xsarwagya/ontoly | 100 | AGPL-3.0 |
| seokan-jeong/team-shinchan | 96 | MIT |
| ginlix-ai/langalpha | 90 | Apache-2.0 |
| cdeust/ai-architect-mcp-codebase | 90 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 4d361378af0d (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100memory-impact-analysis
Ocenia, co się zepsuje po zmianie wskazanego fragmentu kodu, pokazując zależności i zasięg skutków, także dla każdego symbolu z pull requesta. - 100impact
Analizuje wpływ zmian i promień rażenia: co się zepsuje po zmianie danego elementu, z bezpieczną refaktoryzacją i śledzeniem zależności. - 100impact-lens-cli
Analizuje przez CLI Impact Lens wywołujących i tranzytywny wpływ zmiany w kodzie oraz czyta i zarządza notatkami funkcji, wskazując dotknięte wywołania i testy. - 100gitnexus-impact-analysis
Analizuje wpływ zmian w kodzie przez GitNexus: co się zepsuje po zmianie, co od czego zależy i czy edycja jest bezpieczna. - 100anvien-impact-analysis
Ocenia, co się zepsuje po zmianie kodu, i przeprowadza analizę bezpieczeństwa przed edycją. - 85blast-radius
Sprawdza, co zmiana może zepsuć poza własnym diffem: wywołujących, formaty danych, konfigurację i cykl życia, domyślnie tylko do odczytu.