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