git clone https://github.com/Brianmatovu511/millpro-v2.git
cd millpro-v2
docker compose up --build

Open http://localhost:5000

Docker Desktop must be running. Compose starts PostgreSQL and the app together — no .env needed.

1. Open this repo on GitHub
2. Click Code → Codespaces → Create codespace on main
3. Wait ~2 minutes for Docker Compose to build and start
4. Codespaces forwards port 5000 and opens a browser tab automatically
5. The full MillPro app is ready — or visit /demo.html for the one-button DB write demo

A self-contained demo page that requires no login and proves the full stack works end-to-end.

http://localhost:5000/demo.html

Press Log Production Activity — a simulated milling run (maize in, flour out, efficiency %) is written to the PostgreSQL database via the backend, and the last 10 entries appear instantly in the table. This satisfies the INCO "one button → backend → database" verification requirement.

• Node.js ≥ 18
• A PostgreSQL database (local or Neon free tier)

# 1. Install all dependencies
npm run setup

# 2. Configure environment
cp .env.example .env
# Edit .env — set DATABASE_URL and JWT_SECRET

# 3. Set up database
npm run db:push     # push schema
npm run db:seed     # load demo data

# 4. Start dev server
npm run dev         # backend :5000 + frontend :5173

Open http://localhost:5173 and sign in with code JGM001.

millpro-v2/
├── .devcontainer/
│   └── devcontainer.json        # GitHub Codespaces auto-config
├── .github/workflows/
│   └── ci.yml                   # CI/CD: lint → test → Docker build
├── .husky/
│   └── pre-commit               # Lint + tests run before every commit
├── client/
│   ├── public/
│   │   └── demo.html            # One-button demo page (no login)
│   └── src/
│       ├── App.jsx              # Full management dashboard
│       ├── api.js               # Axios API client
│       └── hooks/useAuth.jsx    # Auth context & JWT management
├── server/
│   ├── fhir/                    # FHIR R4 mapper & validator (INCO)
│   ├── middleware/
│   │   ├── auth.js              # JWT authenticate + role authorize
│   │   ├── correlationId.js     # UUID per request for log tracing
│   │   ├── errorHandler.js      # Centralized error handling
│   │   └── validate.js          # Input validation result handler
│   ├── routes/
│   │   ├── demo.js              # Public one-button demo endpoint
│   │   ├── fhir.js              # FHIR R4 Observation API (INCO)
│   │   └── ...                  # All business routes
│   └── utils/
│       └── logger.js            # Winston structured logging
├── tests/                       # Jest test suites (96% line coverage)
├── prisma/schema.prisma         # Full database schema
├── docker-compose.yml           # One-command startup
└── Dockerfile                   # Multi-stage production build

npm run dev          # Start dev server (backend + frontend concurrently)
npm run build        # Build React frontend for production
npm start            # Start production server
npm test             # Run Jest test suite with coverage
npm run lint         # ESLint check
npm run lint:fix     # Auto-fix lint issues
npm run db:push      # Push Prisma schema to database
npm run db:seed      # Seed demo data
npm run db:studio    # Open Prisma Studio (database GUI)
npm run setup        # Full install: deps + Prisma generate

This project was built as part of the Innovation and Complexity Management (INCO) course at TH Deggendorf. The table below maps each evaluation criterion to its implementation.

The system is designed and evaluated against nine quality dimensions used throughout the INCO course.

What humans own:

• Brian defines the backend architecture and reviews every server-side pull request before it merges. He decides what the AI scaffolds are allowed to generate and where the boundaries are.
• Rebecca owns all frontend merges. She uses AI to accelerate component generation but manually reviews every rendered result for design consistency and correctness.
• Aamna translates the professor's rubric and FHIR standards into concrete acceptance criteria. She ensures the team builds the right thing — not just something that runs.
• Pious tracks progress against the INCO evaluation table above, coordinates across the IT and business sides, and runs the final check before any feature is marked done.

What AI agents do:

• Generate boilerplate code (route scaffolding, test stubs, Docker configs, middleware) so Brian and Rebecca spend time on logic, not repetition.
• Perform a first-pass code review — flagging security issues (hardcoded secrets, missing validation, SQL injection patterns) and ESLint violations before a human reviews.
• Write and run test suites autonomously, then report coverage gaps back to the engineer for prioritisation.
• Produce structured documentation drafts (README sections, API tables, FHIR capability statements) that Aamna edits for accuracy and Pious approves for presentation quality.

1. On every push, GitHub Actions runs lint and tests automatically — no human needs to be at a keyboard. The CI badge in this README is the team's live status board.
2. Pre-commit hooks (husky) run lint checks locally before code ever reaches GitHub, catching issues at the earliest possible point.
3. Brian uses Claude Code CLI in the terminal to scaffold new backend routes: he describes the endpoint in plain English, the agent writes the route + middleware + test file, then Brian reviews the diff before committing.
4. Rebecca uses Claude Code to generate React components from a design brief, then refines the output for visual consistency with the existing theme.
5. Aamna runs document-generation prompts against the professor's rubric to produce a requirement traceability matrix — identifying which evaluation criteria are met and which are still gaps.

• The professor's rubric is the single source of truth. Aamna maintains the "Development Checklist" table above, mapping every rubric point to a specific file or test. No feature is "done" until that row is green.
• GitHub is the coordination layer. Every change goes through a pull request. Brian, Rebecca, Aamna, and Pious all receive PR notifications. If the CI badge is red, the whole team stops and fixes it before adding anything new.
• AI agents are given scope, not autonomy. Agents scaffold and suggest; humans approve and merge. If an agent generates code that technically runs but violates the FHIR schema or the professor's architecture requirements, the human reviewer catches it at PR time.
• Weekly 15-minute sync: Pious chairs a standup where each person reports what the CI pipeline and the checklist table show — not what they think is done. This grounds the meeting in observable facts rather than assumptions.

MIT — see LICENSE for details.