Skip to main content

​
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)

​
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 stepsEach 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

Build docs developers (and LLMs) love

Get started for freeTalk to us