deployment-analysis
The deployment-analysis Claude Code skill examines a repository's structure and configuration files to identify its programming language, framework, deployment targets, listening ports, build and start commands, and monorepo organization. Use this skill when onboarding a new repository, planning a deployment, troubleshooting infrastructure setup, or answering questions about a project's technology stack and architecture.
git clone --depth 1 https://github.com/nixopus/nixopus /tmp/deployment-analysis && cp -r /tmp/deployment-analysis/api/skills/deployment-analysis ~/.claude/skills/deployment-analysisSKILL.md
# Deployment Analysis
When analyzing a repository for deployment, follow this sequence using workspace tools.
## Step 1: Project structure
Run `list_directory` on the repo root. Look for:
| File | Meaning |
|------|---------|
| `package.json` | Node.js (check `engines`, `scripts.start`, `scripts.build`) |
| `go.mod` | Go |
| `requirements.txt` / `pyproject.toml` / `Pipfile` | Python |
| `Cargo.toml` | Rust |
| `pom.xml` / `build.gradle` | Java |
| `Gemfile` | Ruby |
| `mix.exs` | Elixir |
| `Dockerfile` | Already containerized |
| `docker-compose.yml` / `docker-compose.yaml` | Multi-service |
| `.env.example` / `.env.sample` | Env vars documented |
## Step 2: Detect ecosystem and framework
Read the manifest file to identify the framework:
**Node.js** — read `package.json`:
- `dependencies.next` → Next.js. Default port 3000. Build: `npm run build`. Start: `npm start`.
- `dependencies.nuxt` → Nuxt. Default port 3000.
- `dependencies.react-scripts` → Create React App. Static build. Port 80 (nginx).
- `dependencies.vite` → Vite app. Build outputs to `dist/`. Static or SSR depending on config.
- `dependencies.express` or `dependencies.fastify` or `dependencies.hono` → API server. Check `scripts.start` for port.
- `dependencies.@remix-run/node` → Remix. Port 3000.
- `dependencies.astro` → Astro. Check if SSR or static.
**Go** — read `go.mod`: Check module path. Look for `main.go` or `cmd/` directory. Default port 8080.
**Python** — read `requirements.txt` or `pyproject.toml`:
- `django` → Django. Default port 8000. Start: `gunicorn` or `python manage.py runserver`.
- `flask` → Flask. Default port 5000. Start: `gunicorn app:app`.
- `fastapi` → FastAPI. Default port 8000. Start: `uvicorn main:app`.
**Rust** — read `Cargo.toml`: Check `[dependencies]` for `actix-web`, `axum`, `rocket`. Default port 8080.
## Step 3: Detect port
Priority order for port detection:
1. `Dockerfile` — look for `EXPOSE` directive
2. `docker-compose.yml` — look for `ports:` mapping
3. `.env.example` — look for `PORT=`
4. Manifest file — check start script for `--port`, `-p`, or `PORT` references
5. Source code — `grep("listen|EXPOSE|PORT", repoRoot)` for hardcoded ports
6. Framework default (see table above)
## Step 4: Monorepo detection
Signs of a monorepo:
- `apps/` or `packages/` or `services/` directories at root
- `turbo.json` or `nx.json` or `lerna.json` or `pnpm-workspace.yaml`
- Multiple `package.json` files in subdirectories
- Multiple `Dockerfile` files in subdirectories
For monorepos:
- Each service under `apps/` or `services/` is a separate deployment target
- Check each service's manifest for its own port and build command
- `docker-compose.yml` is likely needed
- Check for shared dependencies in root `package.json`
## Step 5: Build command detection
| Ecosystem | Install | Build | Start |
|-----------|---------|-------|-------|
| Node (npm) | `npm install` | `npm run build` | `npm start` |
| Node (yarn) | `yarn install` | `yarn build` | `yarn start` |
| Node (pnpm) | `pnpm install` | `pnpm build` | `pnpm start` |
| Go | `go mod download` | `go build -o app ./...` | `./app` |
| Python (pip) | `pip install -r requirements.txt` | n/a | `gunicorn`/`uvicorn` |
| Python (poetry) | `poetry install` | n/a | `poetry run` |
| Rust | n/a | `cargo build --release` | `./target/release/<name>` |
| Java (Maven) | `mvn install` | `mvn package` | `java -jar target/*.jar` |
| Java (Gradle) | `gradle build` | `gradle build` | `java -jar build/libs/*.jar` |
Detect package manager: check for `yarn.lock` (yarn), `pnpm-lock.yaml` (pnpm), `package-lock.json` (npm), `bun.lockb` (bun).
## Output
After analysis, you should know:
- Ecosystem and framework
- Port number
- Build and start commands
- Whether a Dockerfile exists
- Whether docker-compose is needed
- What env vars are required
## Related Skills
- **`env-detection`** — After analysis, detect required environment variables
- **`dockerfile-generation`** — Generate a Dockerfile based on the detected ecosystem
- **`pre-deploy-checklist`** — Validate deployment readiness before triggering a build
- Language-specific skills (`node-deploy`, `python-deploy`, `go-deploy`, etc.) — Detailed build and deploy instructions for the detected ecosystemReference for all Nixopus API operations callable via nixopus_api(method, path, body)
Generate Caddyfile configurations for static sites and reverse proxies — SPA fallback routing, cache headers, compression, redirects, and error pages. Use when deploying a static site that needs custom Caddy configuration, or when the user needs SPA routing, caching, or redirect rules.
Generate docker-compose.yml for multi-service setups including databases, caches, and service dependencies. Use when the app needs a database, cache, message broker, or has multiple independently deployable services.
Size container memory and CPU limits, diagnose OOM kills and CPU throttling, and recommend resource adjustments by ecosystem. Use when containers are being OOM-killed, running slowly, or when setting initial resource limits for a deployment.
Build and deploy C/C++ applications — CMake, Meson, Ninja, and Dockerfile patterns. Use when deploying a C or C++ project, or when CMakeLists.txt or meson.build is detected.
Run database migrations safely during deployment — framework-specific commands, pre-deploy vs post-deploy timing, health gates, and rollback strategies. Use when the app has a database migration system and needs migrations run during deployment.
Build and deploy Deno applications — version detection, dependency caching, and Dockerfile patterns. Use when deploying a Deno project, or when deno.json or deno.jsonc is detected.
Sub-agent routing table — which agent handles diagnostics, machine health, infrastructure, GitHub, billing, and notifications. Load when the current task is not a direct deployment.