AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

dependency-auditor

Use before a release, during a CVE investigation, before a major version bump or for a license review. Scans dependencies with dep_scanner.py, checks licenses with license_checker.py and plans safe upgrades with upgrade_planner.py.

Original source
alirezarezvani
License
MIT
Pinned revision
e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

This skill also requires local files or dependencies. Remote reading alone may not be enough.

Ask your assistant

Use Agentic Memory skills to read alirezarezvani--dependency-auditor at revision e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 8

references/dependency_management_best_practices.md

Dependency Management Best Practices

A comprehensive guide to effective dependency management across the software development lifecycle, covering strategy, governance, security, and operational practices.

Strategic Foundation

Dependency Strategy

Philosophy and Principles

  1. Minimize Dependencies: Every dependency is a liability

    • Prefer standard library solutions when possible
    • Evaluate alternatives before adding new dependencies
    • Regularly audit and remove unused dependencies
  2. Quality Over Convenience: Choose well-maintained, secure dependencies

    • Active maintenance and community
    • Strong security track record
    • Comprehensive documentation and testing
  3. Stability Over Novelty: Prefer proven, stable solutions

    • Avoid dependencies with frequent breaking changes
    • Consider long-term support and backwards compatibility
    • Evaluate dependency maturity and adoption
  4. Transparency and Control: Understand what you're depending on

    • Review dependency source code when possible
    • Understand licensing implications
    • Monitor dependency behavior and updates

Decision Framework

Evaluation Criteria
Dependency Evaluation Scorecard:
│
├── Necessity (25 points)
│   ├── Problem complexity (10)
│   ├── Standard library alternatives (8)
│   └── Internal implementation effort (7)
│
├── Quality (30 points)
│   ├── Code quality and architecture (10)
│   ├── Test coverage and reliability (10)
│   └── Documentation completeness (10)
│
├── Maintenance (25 points)
│   ├── Active development and releases (10)
│   ├── Issue response time (8)
│   └── Community size and engagement (7)
│
└── Compatibility (20 points)
    ├── License compatibility (10)
    ├── Version stability (5)
    └── Platform/runtime compatibility (5)

Scoring:
- 80-100: Excellent choice
- 60-79: Good choice with monitoring
- 40-59: Acceptable with caution
- Below 40: Avoid or find alternatives

Governance Framework

Dependency Approval Process

New Dependency Approval
New Dependency Workflow:
│
1. Developer identifies need
   ├── Documents use case and requirements
   ├── Researches available options
   └── Proposes recommendation
   ↓
2. Technical review
   ├── Architecture team evaluates fit
   ├── Security team assesses risks
   └── Legal team reviews licensing
   ↓
3. Management approval
   ├── Low risk: Tech lead approval
   ├── Medium risk: Architecture board
   └── High risk: CTO approval
   ↓
4. Implementation
   ├── Add to approved dependencies list
   ├── Document usage guidelines
   └── Configure monitoring and alerts
Risk Classification
  • Low Risk: Well-known libraries, permissive licenses, stable APIs
  • Medium Risk: Less common libraries, weak copyleft licenses, evolving APIs
  • High Risk: New/experimental libraries, strong copyleft licenses, breaking changes

Dependency Policies

Licensing Policy
licensing_policy:
  allowed_licenses:
    - MIT
    - Apache-2.0
    - BSD-3-Clause
    - BSD-2-Clause
    - ISC
  
  conditional_licenses:
    - LGPL-2.1  # Library linking only
    - LGPL-3.0  # With legal review
    - MPL-2.0   # File-level copyleft acceptable
  
  prohibited_licenses:
    - GPL-2.0   # Strong copyleft
    - GPL-3.0   # Strong copyleft
    - AGPL-3.0  # Network copyleft
    - SSPL      # Server-side public license
    - Custom    # Unknown/proprietary licenses
  
  exceptions:
    process: "Legal and executive approval required"
    documentation: "Risk assessment and mitigation plan"
Security Policy
security_policy:
  vulnerability_response:
    critical: "24 hours"
    high: "1 week"
    medium: "1 month"
    low: "Next release cycle"
  
  scanning_requirements:
    frequency: "Daily automated scans"
    tools: ["Snyk", "OWASP Dependency Check"]
    ci_cd_integration: "Mandatory security gates"
  
  approval_thresholds:
    known_vulnerabilities: "Zero tolerance for high/critical"
    maintenance_status: "Must be actively maintained"
    community_size: "Minimum 10 contributors or enterprise backing"

Operational Practices

Dependency Lifecycle Management

Addition Process

  1. Research and Evaluation

    # Example evaluation script
    #!/bin/bash
    PACKAGE=$1
    
    echo "=== Package Analysis: $PACKAGE ==="
    
    # Check package stats
    npm view $PACKAGE
    
    # Security audit
    npm audit $PACKAGE
    
    # License check
    npm view $PACKAGE license
    
    # Dependency tree
    npm ls $PACKAGE
    
    # Recent activity
    npm view $PACKAGE --json | jq '.time'
    
  2. Documentation Requirements

    • Purpose: Why this dependency is needed
    • Alternatives: Other options considered and why rejected
    • Risk Assessment: Security, licensing, maintenance risks
    • Usage Guidelines: How to use safely within the project
    • Exit Strategy: How to remove/replace if needed
  3. Integration Standards

    • Pin to specific versions (avoid wildcards)
    • Document version constraints and reasoning
    • Configure automated update policies
    • Add monitoring and alerting

Update Management

Update Strategy
Update Prioritization:
│
├── Security Updates (P0)
│   ├── Critical vulnerabilities: Immediate
│   ├── High vulnerabilities: Within 1 week
│   └── Medium vulnerabilities: Within 1 month
│
├── Maintenance Updates (P1)
│   ├── Bug fixes: Next minor release
│   ├── Performance improvements: Next minor release
│   └── Deprecation warnings: Plan for major release
│
└── Feature Updates (P2)
    ├── Minor versions: Quarterly review
    ├── Major versions: Annual planning cycle
    └── Breaking changes: Dedicated migration projects
Update Process
update_workflow:
  automated:
    patch_updates:
      enabled: true
      auto_merge: true
      conditions:
        - tests_pass: true
        - security_scan_clean: true
        - no_breaking_changes: true
    
    minor_updates:
      enabled: true
      auto_merge: false
      requires: "Manual review and testing"
    
    major_updates:
      enabled: false
      requires: "Full impact assessment and planning"

  testing_requirements:
    unit_tests: "100% pass rate"
    integration_tests: "Full test suite"
    security_tests: "Vulnerability scan clean"
    performance_tests: "No regression"

  rollback_plan:
    automated: "Failed CI/CD triggers automatic rollback"
    manual: "Documented rollback procedure"
    monitoring: "Real-time health checks post-deployment"

Removal Process

  1. Deprecation Planning

    • Identify deprecated/unused dependencies
    • Assess removal impact and effort
    • Plan migration timeline and strategy
    • Communicate to stakeholders
  2. Safe Removal

    # Example removal checklist
    echo "Dependency Removal Checklist:"
    echo "1. [ ] Grep codebase for all imports/usage"
    echo "2. [ ] Check if any other dependencies require it"
    echo "3. [ ] Remove from package files"
    echo "4. [ ] Run full test suite"
    echo "5. [ ] Update documentation"
    echo "6. [ ] Deploy with monitoring"
    

Version Management

Semantic Versioning Strategy

Version Pinning Policies
version_pinning:
  production_dependencies:
    strategy: "Exact pinning"
    example: "react: 18.2.0"
    rationale: "Predictable builds, security control"
  
  development_dependencies:
    strategy: "Compatible range"
    example: "eslint: ^8.0.0"
    rationale: "Allow bug fixes and improvements"
  
  internal_libraries:
    strategy: "Compatible range"
    example: "^1.2.0"
    rationale: "Internal control, faster iteration"
Update Windows
  • Patch Updates (x.y.Z): Allow automatically with testing
  • Minor Updates (x.Y.z): Review monthly, apply quarterly
  • Major Updates (X.y.z): Annual review cycle, planned migrations

Lockfile Management

Best Practices
  1. Always Commit Lockfiles

    • package-lock.json (npm)
    • yarn.lock (Yarn)
    • Pipfile.lock (Python)
    • Cargo.lock (Rust)
    • go.sum (Go)
  2. Lockfile Validation

    # Example CI validation
    - name: Validate lockfile
      run: |
        npm ci --audit
        npm audit --audit-level moderate
        # Verify lockfile is up to date
        npm install --package-lock-only
        git diff --exit-code package-lock.json
    
  3. Regeneration Policy

    • Regenerate monthly or after significant updates
    • Always regenerate after security updates
    • Document regeneration in change logs

Security Management

Vulnerability Management

Continuous Monitoring

monitoring_stack:
  scanning_tools:
    - name: "Snyk"
      scope: "All ecosystems"
      frequency: "Daily"
      integration: "CI/CD + IDE"
    
    - name: "GitHub Dependabot"
      scope: "GitHub repositories"
      frequency: "Real-time"
      integration: "Pull requests"
    
    - name: "OWASP Dependency Check"
      scope: "Java/.NET focus"
      frequency: "Build pipeline"
      integration: "CI/CD gates"

  alerting:
    channels: ["Slack", "Email", "PagerDuty"]
    escalation:
      critical: "Immediate notification"
      high: "Within 1 hour"
      medium: "Daily digest"

Response Procedures

Critical Vulnerability Response
Critical Vulnerability (CVSS 9.0+) Response:
│
0-2 hours: Detection & Assessment
├── Automated scan identifies vulnerability
├── Security team notified immediately
└── Initial impact assessment started
│
2-6 hours: Planning & Communication
├── Detailed impact analysis completed
├── Fix strategy determined
├── Stakeholder communication initiated
└── Emergency change approval obtained
│
6-24 hours: Implementation & Testing
├── Fix implemented in development
├── Security testing performed
├── Limited rollout to staging
└── Production deployment prepared
│
24-48 hours: Deployment & Validation
├── Production deployment executed
├── Monitoring and validation performed
├── Post-deployment testing completed
└── Incident documentation finalized

Supply Chain Security

Source Verification

  1. Package Authenticity

    • Verify package signatures when available
    • Use official package registries
    • Check package maintainer reputation
    • Validate download checksums
  2. Build Reproducibility

    • Use deterministic builds where possible
    • Pin dependency versions exactly
    • Document build environment requirements
    • Maintain build artifact checksums

Dependency Provenance

provenance_tracking:
  metadata_collection:
    - package_name: "Library identification"
    - version: "Exact version used"
    - source_url: "Official repository"
    - maintainer: "Package maintainer info"
    - license: "License verification"
    - checksum: "Content verification"
  
  verification_process:
    - signature_check: "GPG signature validation"
    - reputation_check: "Maintainer history review"
    - content_analysis: "Static code analysis"
    - behavior_monitoring: "Runtime behavior analysis"

Multi-Language Considerations

Ecosystem-Specific Practices

JavaScript/Node.js

{
  "npm_practices": {
    "package_json": {
      "engines": "Specify Node.js version requirements",
      "dependencies": "Production dependencies only",
      "devDependencies": "Development tools and testing",
      "optionalDependencies": "Use sparingly, document why"
    },
    "security": {
      "npm_audit": "Run in CI/CD pipeline",
      "package_lock": "Always commit to repository",
      "registry": "Use official npm registry or approved mirrors"
    },
    "performance": {
      "bundle_analysis": "Regular bundle size monitoring",
      "tree_shaking": "Ensure unused code is eliminated",
      "code_splitting": "Lazy load dependencies when possible"
    }
  }
}

Python

python_practices:
  dependency_files:
    requirements.txt: "Pin exact versions for production"
    requirements-dev.txt: "Development dependencies"
    setup.py: "Package distribution metadata"
    pyproject.toml: "Modern Python packaging"
  
  virtual_environments:
    purpose: "Isolate project dependencies"
    tools: ["venv", "virtualenv", "conda", "poetry"]
    best_practice: "One environment per project"
  
  security:
    tools: ["safety", "pip-audit", "bandit"]
    practices: ["Pin versions", "Use private PyPI if needed"]

Java/Maven

<!-- Maven best practices -->
<properties>
  <!-- Define version properties -->
  <spring.version>5.3.21</spring.version>
  <junit.version>5.8.2</junit.version>
</properties>

<dependencyManagement>
  <!-- Centralize version management -->
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-bom</artifactId>
      <version>${spring.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

Cross-Language Integration

API Boundaries

  • Define clear service interfaces
  • Use standard protocols (HTTP, gRPC)
  • Document API contracts
  • Version APIs independently

Shared Dependencies

  • Minimize shared dependencies across services
  • Use containerization for isolation
  • Document shared dependency policies
  • Monitor for version conflicts

Performance and Optimization

Bundle Size Management

Analysis Tools

# JavaScript bundle analysis
npm install -g webpack-bundle-analyzer
webpack-bundle-analyzer dist/main.js

# Python package size analysis
pip install pip-audit
pip-audit --format json | jq '.dependencies[].package_size'

# General dependency tree analysis
dep-tree analyze --format json --output deps.json

Optimization Strategies

  1. Tree Shaking: Remove unused code
  2. Code Splitting: Load dependencies on demand
  3. Polyfill Optimization: Only include needed polyfills
  4. Alternative Packages: Choose smaller alternatives when possible

Build Performance

Dependency Caching

# Example CI/CD caching
cache_strategy:
  node_modules:
    key: "npm-{{ checksum 'package-lock.json' }}"
    paths: ["~/.npm", "node_modules"]
  
  pip_cache:
    key: "pip-{{ checksum 'requirements.txt' }}"
    paths: ["~/.cache/pip"]
  
  maven_cache:
    key: "maven-{{ checksum 'pom.xml' }}"
    paths: ["~/.m2/repository"]

Parallel Installation

  • Configure package managers for parallel downloads
  • Use local package caches
  • Consider dependency proxies for enterprise environments

Monitoring and Metrics

Key Performance Indicators

Security Metrics

security_kpis:
  vulnerability_metrics:
    - mean_time_to_detection: "Average time to identify vulnerabilities"
    - mean_time_to_patch: "Average time to fix vulnerabilities"
    - vulnerability_density: "Vulnerabilities per 1000 dependencies"
    - false_positive_rate: "Percentage of false vulnerability reports"
  
  compliance_metrics:
    - license_compliance_rate: "Percentage of compliant dependencies"
    - policy_violation_rate: "Rate of policy violations"
    - security_gate_success_rate: "CI/CD security gate pass rate"

Operational Metrics

operational_kpis:
  maintenance_metrics:
    - dependency_freshness: "Average age of dependencies"
    - update_frequency: "Rate of dependency updates"
    - technical_debt: "Number of outdated dependencies"
  
  performance_metrics:
    - build_time: "Time to install/build dependencies"
    - bundle_size: "Final application size"
    - dependency_count: "Total number of dependencies"

Dashboard and Reporting

Executive Dashboard

  • Overall risk score and trend
  • Security compliance status
  • Cost of dependency management
  • Policy violation summary

Technical Dashboard

  • Vulnerability count by severity
  • Outdated dependency count
  • Build performance metrics
  • License compliance details

Automated Reports

  • Weekly security summary
  • Monthly compliance report
  • Quarterly dependency review
  • Annual strategy assessment

Team Organization and Training

Roles and Responsibilities

Security Champions

  • Monitor security advisories
  • Review dependency security scans
  • Coordinate vulnerability responses
  • Maintain security policies

Platform Engineers

  • Maintain dependency management infrastructure
  • Configure automated scanning and updates
  • Manage package registries and mirrors
  • Support development teams

Development Teams

  • Follow dependency policies
  • Perform regular security updates
  • Document dependency decisions
  • Participate in security training

Training Programs

Security Training

  • Dependency security fundamentals
  • Vulnerability assessment and response
  • Secure coding practices
  • Supply chain attack awareness

Tool Training

  • Package manager best practices
  • Security scanning tool usage
  • CI/CD security integration
  • Incident response procedures

Conclusion

Effective dependency management requires a holistic approach combining technical practices, organizational policies, and cultural awareness. Key success factors:

  1. Proactive Strategy: Plan dependency management from project inception
  2. Clear Governance: Establish and enforce dependency policies
  3. Automated Processes: Use tools to scale security and maintenance
  4. Continuous Monitoring: Stay informed about dependency risks and updates
  5. Team Training: Ensure all team members understand security implications
  6. Regular Review: Periodically assess and improve dependency practices

Remember that dependency management is an investment in long-term project health, security, and maintainability. The upfront effort to establish good practices pays dividends in reduced security risks, easier maintenance, and more stable software systems.