/dependencies

allowed-tools: Bash(fd:*), Bash(rg:*), Bash(git:*), Bash(npm:*), Bash(cargo:*), Bash(go:*), Bash(jq:*), Bash(gdate:*), Read, Write, Task
name: "Dependencies"
description: "Ultra-fast parallel dependency analysis using 10 sub-agents for 10x speedup"
author: "wcygan"
tags: ["code","analyze"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

/dependencies

Context

• Session ID: !`gdate +%s%N`
• Current directory: !`pwd`
• Project structure: !`fd . -t d -d 2 | head -10 || echo "Limited directory access"`
• Technology files: !`fd -e json -e toml -e xml -e txt -e lock . | rg "(package\.json|Cargo\.toml|go\.mod|pom\.xml|requirements\.txt|composer\.json|yarn\.lock|Cargo\.lock)" | head -10 || echo "No dependency files found"`
• Dependency directories: !`fd "(node_modules|target|vendor|build)" -t d | head -5 || echo "No dependency directories found"`
• Git repository: !`git status --porcelain | head -5 2>/dev/null || echo "Not a git repository"`
• Current branch: !`git branch --show-current 2>/dev/null || echo "No git repository"`

Analyze and visualize dependency relationships, impact analysis, and coupling patterns within codebases, systems, or project components.

Your Task

**IMMEDIATELY DEPLOY 10 PARALLEL SUB-AGENTS** for lightning-fast dependency analysis of: $ARGUMENTS

Think hard about complex dependency relationships while maximizing parallel execution.

Parallel Sub-Agent Execution Framework

STEP 1: Initialize Analysis Session

• Create session state file: /tmp/dependency-analysis-$SESSION_ID.json
• Initialize results directory: /tmp/dependency-results-$SESSION_ID/
• Set up checkpoint system for parallel agent coordination
• Determine analysis scope: $ARGUMENTS

STEP 2: **LAUNCH ALL 10 AGENTS SIMULTANEOUSLY**

**NO SEQUENTIAL PROCESSING** - Deploy these agents in parallel:

1. **Technology Stack Agent**: Detect all languages, frameworks, and build tools 2. **Direct Dependencies Agent**: Analyze explicit package dependencies 3. **Transitive Dependencies Agent**: Map entire dependency tree 4. **Import Analysis Agent**: Scan all import/require statements 5. **Infrastructure Dependencies Agent**: Find Docker, K8s, cloud dependencies 6. **Runtime Dependencies Agent**: Identify DB, API, service dependencies 7. **Security Analysis Agent**: Scan for vulnerabilities and outdated packages 8. **Coupling Analysis Agent**: Measure component interdependencies 9. **Circular Dependencies Agent**: Detect dependency cycles 10. **License Compliance Agent**: Check license compatibility

Each agent operates independently to maximize performance.

STEP 3: Parallel Dependency Discovery

**ALL AGENTS WORK CONCURRENTLY:**

**Code-Level Dependencies Discovery:**

# Language-specific dependency files
fd "package.json|Cargo.toml|go.mod|pom.xml|requirements.txt|composer.json" --type f || echo "No dependency files found"

# Import/require statements analysis
rg "import|require|use|from|include" -n --type-add 'code:*.{rs,go,java,ts,js,py,cpp,h}' | head -20 || echo "No import statements found"

# Internal module dependencies
rg "\.\/|\.\.\/|@\/" -n | head -15 || echo "No relative imports found"
rg "src\/|lib\/|internal\/" -n | head -15 || echo "No internal imports found"

**Infrastructure Dependencies:**

# Container and orchestration dependencies
fd "Dockerfile|docker-compose|k8s|kubernetes" --type f || echo "No container configs found"
rg "image:|FROM|depends_on|volumes_from" --type yaml --type dockerfile | head -10 || echo "No container dependencies found"

# Service mesh and networking
rg "Service|Ingress|ConfigMap|Secret" --type yaml | head -10 || echo "No k8s resources found"
rg "host:|port:|endpoint:|url:" --type yaml --type json | head -10 || echo "No network configs found"

**Runtime Dependencies:**

# Database and external service connections
rg "database|db|postgres|mysql|redis|mongo" -i -A 2 -B 1 | head -15 || echo "No database dependencies found"
rg "http:|https:|grpc:|tcp:|amqp:" -A 1 -B 1 | head -15 || echo "No network protocols found"
rg "api\..*\.|client\.|service\." -A 1 -B 1 | head -15 || echo "No service dependencies found"

STEP 4: Technology-Specific Dependency Analysis

Phase 2: Dependency Mapping

**Direct Dependencies**

• First-order dependencies explicitly declared or imported
• Version constraints and compatibility requirements
• Mandatory vs. optional dependencies
• Development vs. production dependencies

**Transitive Dependencies**

# Dependency tree analysis
npm ls --all  # Node.js full dependency tree
cargo tree  # Rust dependency tree
go mod graph  # Go module dependencies
mvn dependency:tree  # Maven dependency tree

**Circular Dependencies**

# Find potential circular imports
rg "import.*from ['\"]\.\./" -A 1 -B 1
# Look for module cycles in different languages
madge --circular src/  # JavaScript/TypeScript
cargo tree --duplicates  # Rust duplicates (potential cycles)

**Hidden Dependencies**

• Runtime service discovery dependencies
• Configuration-based dependencies
• Environment variable dependencies
• Network protocol dependencies

Phase 3: Impact Analysis

**Dependency Hierarchy**

## Dependency Layers

### Layer 1: Core/Foundation

- [Base libraries and frameworks]
- [System-level dependencies]
- [Critical infrastructure components]

### Layer 2: Business Logic

- [Domain-specific libraries]
- [Application frameworks]
- [Business service dependencies]

### Layer 3: Presentation/Interface

- [UI frameworks and components]
- [API client libraries]
- [Protocol implementations]

### Layer 4: Integration/External

- [Third-party services]
- [External APIs]
- [Vendor-specific tools]

**Change Impact Scoring**

## Dependency Risk Matrix

| Component     | Dependents | Risk Level | Impact Scope  | Change Frequency |
| ------------- | ---------- | ---------- | ------------- | ---------------- |
| [Component A] | 15         | HIGH