Google/Skills Dependencies: Complete Guide to Package Files and Runtime Requirements

The google/skills repository manages dependencies at the skill level, with each instructional skill declaring its own runtime libraries in language-specific manifest files such as package.json, requirements.txt, pom.xml, or go.mod.

The Google Skills repository is a collection of instructional "skills" implemented across multiple programming languages and cloud environments. Unlike monolithic projects with a single root dependency file, google/skills follows a distributed approach where each skill maintains its own dependency declarations. This article examines the primary dependency files, with detailed analysis of the Node.js dependencies found in the GKE App Onboarding skill.

Primary JavaScript Dependencies in skills/cloud/gke-app-onboarding

The most prominent dependency file in the repository is located within the GKE App Onboarding skill's asset bundle. This skill demonstrates Google Kubernetes Engine deployment patterns and requires a substantial set of Google Cloud and utility libraries.

File: skills/cloud/gke-app-onboarding/assets/package.json

In skills/cloud/gke-app-onboarding/assets/package.json, the project declares both production and development dependencies. The following table lists the production dependencies as implemented in google/skills:

Dependency	Version	Purpose
@google-cloud/gke	^0.4.0	Google Kubernetes Engine client
@google-cloud/storage	^6.9.0	Cloud Storage operations
commander	^9.4.1	CLI argument parsing
dotenv	^16.0.3	Environment variable management
express	^4.18.2	HTTP server framework
google-auth-library	^8.7.0	Google API authentication
helmet	^6.0.0	Security middleware for Express
jsonwebtoken	^9.0.0	JWT token handling
kubernetes-client	^9.2.0	Kubernetes API client
prettier	^2.8.4	Code formatting
winston	^3.8.2	Structured logging

The development dependencies in the same package.json support testing and code quality:

Dev Dependency	Version
jest	^29.5.0
eslint	^8.35.0
eslint-config-prettier	^8.6.0
supertest	^6.3.3

Installing and Using Dependencies

To work with the google/skills JavaScript dependencies locally, clone the repository and install packages from the specific skill directory:

# Clone the google/skills repository

git clone https://github.com/google/skills.git
cd skills/skills/cloud/gke-app-onboarding/assets

# Install all declared dependencies

npm install

The installed packages enable server implementation patterns shown throughout the skill's source code. A typical server setup using these dependencies would look like:

// Example usage pattern based on google/skills implementation
const express = require('express');
const {GoogleAuth} = require('google-auth-library');
const {KubeConfig} = require('kubernetes-client');
const helmet = require('helmet');
const winston = require('winston');

const app = express();

// Security middleware
app.use(helmet());

// Structured logging
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [new winston.transports.Console()]
});

// Google Cloud authentication
const auth = new GoogleAuth({
  scopes: ['https://www.googleapis.com/auth/cloud-platform']
});

// Health check endpoint
app.get('/healthz', (req, res) => res.send('OK'));

app.listen(8080, () => {
  logger.info('GKE onboarding service listening on port 8080');
});

Language-Specific Dependency Patterns in google/skills

The repository contains skills implemented across multiple languages, each following established conventions for dependency management:

Language	Manifest File	Typical Location Pattern
Python	requirements.txt	skills/*/*/references/requirements.txt
Java	pom.xml	skills/*/*/references/pom.xml
Go	go.mod	skills/*/*/references/go.mod
.NET	*.csproj	skills/*/*/references/*.csproj
Ruby	Gemfile	skills/*/*/references/Gemfile

Python Skill Dependencies

For Python-based skills in google/skills, dependency installation follows standard pip patterns:

# Navigate to a Python skill's reference implementation

cd skills/analytics/google-analytics-data-api-basics/references

# Install dependencies

pip install -r requirements.txt

Java Skill Dependencies

Java skills use Maven coordinates declared in pom.xml:

# Build a Java skill

cd skills/analytics/google-analytics-data-api-basics/references
mvn dependency:resolve

Key Dependency Files Reference

The following paths represent the primary dependency declarations across the google/skills repository:

Path	Language	Purpose
skills/cloud/gke-app-onboarding/assets/package.json	JavaScript	Node.js runtime for GKE deployment skill
skills/*/*/references/requirements.txt	Python	pip-installable packages
skills/*/*/references/pom.xml	Java	Maven dependencies and build configuration
skills/*/*/references/go.mod	Go	Module dependencies and Go version
skills/*/*/references/Gemfile	Ruby	Bundler gem specifications
skills/*/*/references/*.csproj	.NET	NuGet package references

Summary

• google/skills uses skill-level dependency management rather than a root manifest file
• The primary JavaScript dependencies are located in skills/cloud/gke-app-onboarding/assets/package.json and include Google Cloud clients, Express, authentication libraries, and Kubernetes tools
• Development dependencies include Jest for testing, ESLint for linting, and Supertest for HTTP assertions
• Each programming language follows its standard tooling: npm for JavaScript, pip for Python, Maven for Java, Go modules for Go, Bundler for Ruby, and NuGet for .NET
• Always consult the specific skill's README to locate its dependency manifest

Frequently Asked Questions

Does google/skills have a single package.json at the repository root?

No. The google/skills repository does not use a root-level dependency file. Each skill maintains its own manifest in the appropriate location for its implementation language, typically within a references/ or assets/ subdirectory.

How do I find dependencies for a specific skill in google/skills?

Check the skill's directory structure for language-specific files. JavaScript skills use package.json, Python skills use requirements.txt, Java skills use pom.xml, and Go skills use go.mod. The skill's README typically documents the correct installation command.

Are the google/skills dependencies kept up to date?

According to the source code analysis, the GKE App Onboarding skill uses caret (^) version ranges in its package.json, allowing compatible minor and patch updates. Specific pinned versions would be recorded in the package-lock.json file, which should be committed for reproducible builds.

What authentication libraries does google/skills use for Google Cloud APIs?

The primary package.json in skills/cloud/gke-app-onboarding/assets/package.json declares google-auth-library at version ^8.7.0 as the authentication mechanism for Google Cloud API calls.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}