Deployment Analysis

DevOps & Security

deployment-analysis

Deployment Analysis is an Agent Skill for devops & security published in the nixopus/nixopus repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

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.

View on GitHub ↗

QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

Open your project in Codex.
Copy and paste the prompt below.
Review files and risks before approving any action.

Prompt to paste

Inspect the Agent Skill at https://github.com/nixopus/nixopus/blob/HEAD/api/skills/deployment-analysis/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/deployment-analysis, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

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:

Dockerfile — look for EXPOSE directive
docker-compose.yml — look for ports: mapping
.env.example — look for PORT=
Manifest file — check start script for --port, -p, or PORT references
Source code — grep("listen|EXPOSE|PORT", repoRoot) for hardcoded ports
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