Processes Resources

Execution flows traced from entry points through call chains

gitnexus://repo//processes

Resource URI

gitnexus://repo/{name}/processes

name · string · required

Repository name from gitnexus://repos

Description

Returns all execution flows (processes) detected in the repository. Processes trace code execution paths from entry points through function call chains.

Processes represent how code actually runs — user login flow, API request handling, database migration, etc.

Returns

processes · array

List of detected execution flows (top 20)

Show properties

name · string

Human-readable process label (heuristic-based)

type · string

Process type: api, cli, event, init, or unknown

steps · number

Number of execution steps (function calls) in the trace

When to Use

• Understanding execution flows: See how code actually runs
• Debugging: Trace execution paths
• Impact analysis: Identify affected workflows
• Documentation: Generate flow diagrams
• Onboarding: Learn major user journeys

Example Response

With Processes

processes:
  - name: "User Login Flow"
    type: api
    steps: 12
  - name: "Order Checkout"
    type: api
    steps: 23
  - name: "Database Migration"
    type: cli
    steps: 8
  - name: "Payment Processing"
    type: event
    steps: 15
  - name: "Server Initialization"
    type: init
    steps: 34

# Showing top 20 of 87 processes. Use gitnexus_query for deeper search.

No Processes

processes: []
# No processes detected. Run: gitnexus analyze

Process Types

GitNexus categorizes processes by their entry point:

• api: HTTP request handlers, REST endpoints, GraphQL resolvers
• cli: Command-line commands, scripts
• event: Event handlers, message queue consumers, webhooks
• init: Application initialization, startup sequences
• unknown: Other execution flows

---

gitnexus://repo//process/

Resource URI

gitnexus://repo/{name}/process/{processName}

name · string · required

Repository name from gitnexus://repos

processName · string · required

Process name from the processes resource

Description

Returns a step-by-step execution trace for a specific process, showing the exact sequence of function calls and their file locations.

Use this to trace an execution flow from start to finish.

Returns

name · string

Process name

type · string

Process type (api, cli, event, init, unknown)

step_count · number

Total number of steps

trace · array

Ordered list of execution steps

Each step shows: {stepNumber}: {symbolName} ({filePath})

When to Use

• After reading processes: Deep-dive into specific flows
• Debugging: Follow execution path to find bugs
• Understanding flow: See exact call sequence
• Impact analysis: Identify all functions in a critical path
• Documentation: Generate sequence diagrams

Example Response

name: "User Login Flow"
type: api
step_count: 12

trace:
  1: loginHandler (src/routes/auth.ts)
  2: validateCredentials (src/auth/validate.ts)
  3: hashPassword (src/auth/utils.ts)
  4: findUserByEmail (src/db/users.ts)
  5: comparePasswords (src/auth/utils.ts)
  6: generateToken (src/auth/tokens.ts)
  7: signJWT (src/auth/jwt.ts)
  8: createSession (src/db/sessions.ts)
  9: insertSession (src/db/queries.ts)
  10: auditLog (src/logging/audit.ts)
  11: sendWelcomeEmail (src/email/templates.ts)
  12: returnResponse (src/routes/auth.ts)

Error Response

error: Process "InvalidName" not found

Understanding Traces

Each step in a trace represents:

1. Step number: Execution order (1-based)
2. Symbol name: Function or method being called
3. File path: Location of the symbol

The trace shows the depth-first traversal of the call graph from the entry point.

Workflow

Typical process exploration workflow:

1. List All Processes

   Read gitnexus://repo/{name}/processes to see available flows

2. Identify Critical Flows

   Look for API endpoints, important events, or areas you’re working on

3. Trace Execution

   Read gitnexus://repo/{name}/process/{processName} for specific flows

4. Analyze Impact

   Use the impact tool on symbols in the trace to check blast radius

Use Cases

Debugging

When tracing a bug in the login flow:

# 1. Find the process
Read: gitnexus://repo/my-app/processes

# 2. Get the full trace
Read: gitnexus://repo/my-app/process/User Login Flow

# 3. Analyze suspicious steps
Tool: context({name: "validateCredentials"})
Tool: impact({target: "validateCredentials", direction: "upstream"})

Impact Analysis

Before modifying a function, check which processes it affects:

# 1. List processes
Read: gitnexus://repo/my-app/processes

# 2. Check specific flows that might be affected
Read: gitnexus://repo/my-app/process/User Login Flow
Read: gitnexus://repo/my-app/process/Password Reset

Documentation

Generate flow diagrams:

# 1. Get top processes
Read: gitnexus://repo/my-app/processes

# 2. Get traces for key flows
Read: gitnexus://repo/my-app/process/Order Checkout
Read: gitnexus://repo/my-app/process/Payment Processing

# 3. Generate mermaid diagrams from traces

Next Steps

Impact Tool

Analyze blast radius of changes

Detect Changes Tool

Map git diff to affected processes