Dhpk Gitnexus Impact Analysis

---
name: dhpk-gitnexus-impact-analysis
description: 'Assess the blast radius of a code change via the GitNexus graph. Use when: asking what breaks if you change X, who depends on a symbol, or for a pre-commit safety check. Not for: understanding how code works (use dhpk-gitnexus-exploring), bug tracing (use dhpk-gitnexus-debugging), performing the rename/refactor (use dhpk-gitnexus-refactoring). Output: a depth-ranked dependents list + risk level.'
metadata:
  dhpk-invocation-class: implicit-eligible
---

# Impact Analysis with GitNexus

## When to Use

- "Is it safe to change this function?"
- "What will break if I modify X?"
- "Show me the blast radius"
- "Who uses this code?"
- Before making non-trivial code changes
- Before committing — to understand what your changes affect

## Workflow

```
1. gitnexus_impact({target: "X", direction: "upstream"})  → What depends on this
2. READ gitnexus://repo/{name}/processes                   → Check affected execution flows
3. gitnexus_detect_changes()                               → Map current git changes to affected flows
4. Assess risk and report to user
```

> If the context reports a stale index, follow `dhpk-gitnexus-guide` for the
> single stale-index recovery path before continuing this workflow.

## Checklist

```
- [ ] gitnexus_impact({target, direction: "upstream"}) to find dependents
- [ ] Review d=1 items first (these WILL BREAK)
- [ ] Check high-confidence (>0.8) dependencies
- [ ] READ processes to check affected execution flows
- [ ] gitnexus_detect_changes() for pre-commit check
- [ ] Assess risk level and report to user
```

## Output

Return a compact report containing the target symbol, index freshness, direct
callers, affected execution flows, risk level, and next verification commands.
Mark graph gaps, dynamic references, and external consumers as uncertainties
instead of treating the graph as exhaustive.

## Verification

- [ ] The target and direction used for `gitnexus_impact` are recorded.
- [ ] Direct dependents are separated from indirect dependents.
- [ ] Affected process resources were checked, not inferred from callers only.
- [ ] HIGH or CRITICAL risk is surfaced before any edit proceeds.
- [ ] `gitnexus_detect_changes` is run before commit when the task changes code.

The schema, tool names, resource catalog, and stale-index recovery are owned by
`dhpk-gitnexus-guide`; this skill owns blast-radius sequencing and risk output.

## Understanding Output

| Depth | Risk Level       | Meaning                  |
| ----- | ---------------- | ------------------------ |
| d=1   | **WILL BREAK**   | Direct callers/importers |
| d=2   | LIKELY AFFECTED  | Indirect dependencies    |
| d=3   | MAY NEED TESTING | Transitive effects       |

## Risk Assessment

| Affected                       | Risk     |
| ------------------------------ | -------- |
| <5 symbols, few processes      | LOW      |
| 5-15 symbols, 2-5 processes    | MEDIUM   |
| >15 symbols or many processes  | HIGH     |
| Critical path (auth, payments) | CRITICAL |

## Tools

**gitnexus_impact** — the primary tool for symbol blast radius:

```
gitnexus_impact({
  target: "validateUser",
  direction: "upstream",
  minConfidence: 0.8,
  maxDepth: 3
})

→ d=1 (WILL BREAK):
  - loginHandler (src/auth/login.ts:42) [CALLS, 100%]
  - apiMiddleware (src/api/middleware.ts:15) [CALLS, 100%]

→ d=2 (LIKELY AFFECTED):
  - authRouter (src/routes/auth.ts:22) [CALLS, 95%]
```

**gitnexus_detect_changes** — git-diff based impact analysis:

```
gitnexus_detect_changes({scope: "staged"})

→ Changed: 5 symbols in 3 files
→ Affected: LoginFlow, TokenRefresh, APIMiddlewarePipeline
→ Risk: MEDIUM
```

## Example: "What breaks if I change validateUser?"

```
1. gitnexus_impact({target: "validateUser", direction: "upstream"})
   → d=1: loginHandler, apiMiddleware (WILL BREAK)
   → d=2: authRouter, sessionManager (LIKELY AFFECTED)

2. READ gitnexus://repo/my-app/processes
   → LoginFlow and TokenRefresh touch validateUser

3. Risk: 2 direct callers, 2 processes = MEDIUM
```

## When NOT to Use

- You want to understand how the code works → `dhpk-gitnexus-exploring`
- You are tracing a specific bug → `dhpk-gitnexus-debugging`
- You are ready to perform the rename / extract / split → `dhpk-gitnexus-refactoring`