# Deployment Analysis

> Analyze a repository to determine ecosystem, deployment targets, ports, build commands, and monorepo structure. Use when starting a new deployment, onboarding a repository, or when the user asks what stack or framework a project uses.

- Skill: `nixopus/deployment-analysis` (Agent Skill)
- Install (CLI): `npx skillmds@latest add nixopus/deployment-analysis`
- Raw SKILL.md: https://api.skillmd.com/api/skills/nixopus/deployment-analysis/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: nixopus (https://skillmd.com/u/nixopus)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/nixopus/deployment-analysis

---


# 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 ecosystem