AI Indie Game Publisher (Indie Launch)

AI Indie Game Publisher is an assistant for indie teams to make smarter publishing decisions. It offers data‑driven pricing suggestions, release date guidance, and platform rubric Q&A for Steam, Epic Games Store, GOG, itch.io, and consoles.

Highlights

• Smart Pricing: recommend price and range from category baselines, production quality, and content hours with quick visual comparisons.
• Release Date Advisor: flag major releases, platform sales, and events with impact levels to avoid conflicts and find better windows.
• Platform Rubric Q&A: instant, structured answers to common platform requirements (fees, revenue split, submission flow, SDK, assets).
• Game Registration & Details: track engine, category, target platforms, planned release date, and repo links.

Note: Pricing, calendar, and Q&A currently use frontend prototype logic with mock/reference data; backend integration and live data sources are on the roadmap.

Tech Stack

• Backend: Go, Echo (HTTP), GORM (ORM), PostgreSQL, JWT auth
• Frontend: React, React Router, Recharts, Lucide Icons, Tailwind utility classes (design), Vite
• Core: Python, FastAPI, ChromaDB, OpenAI Embeddings, Pydantic, Google Cloud Storage (see core/README.md for details)

AI & Data Architecture

• Steam Integrations: use Steam APIs and scraped datasets for wishlist games, review summaries, and calendar events, powering launch guidance and monitoring (see backend/pkg/steam, backend/pkg/wishlist, backend/pkg/calendar and related scripts).
• RAG Knowledge Base: a separate Python Core service exposes /rag/* endpoints backed by ChromaDB and OpenAI (embeddings + ChatOpenAI) to answer platform and publishing questions over scraped docs (see core/data, core/rag, core/service).
• Pricing Model on Modal: a fine‑tuned Qwen pricing model is deployed on Modal and called from the Go backend via the Modal.URL config to predict Steam‑style prices from rich game metadata (see core/utils/modal/app.py and backend/pkg/modal).

Structure

indie-launch/
  backend/
    bin/server/main.go        # service entry
    pkg/app/                  # service wiring and routes
    pkg/auth/                 # register/login, JWT, sessions
    pkg/config/               # config/credentials loader (WIP)

  frontend/
    App.jsx                   # app shell and navigation
    HomePage.jsx              # overview and feature entry points
    GameRegistration.jsx      # game entry form
    GameDetails.jsx           # per‑game view
    ChatbotPage.jsx           # platform rubric Q&A (prototype)
    CalendarPage.jsx          # release calendar (mock data)
    PricingPage.jsx           # pricing recommendations (prototype)
    App.css, index.html, components/ui/button.jsx
    src/main.jsx              # Vite entry
    package.json, vite.config.js, Dockerfile

  core/                       # RAG system for AI capabilities
    data/
      loader.py               # web scraping & GCS bucket sync
      bucket.py               # Google Cloud Storage operations
      models.py               # WebPage and data type definitions
      webset.py               # curated web sources
      main.py                 # CLI for data operations
    rag/
      chromadb.py             # VectorStore wrapper & operations
      models.py               # Document and metadata models
    service/
      app.py                  # FastAPI application
      routes.py               # REST API endpoints
      models.py               # request/response models
    config.py                 # centralized settings
    README.md                 # full core documentation

  docs/
    images/
      workflow.png

Routes (Frontend)

Access here: http://game.lucas-ty.com (for demo only)

• / Home
• /register Game Registration
• /game/:id Game Details
• /chatbot Platform Rubric Q&A
• /calendar Release Calendar
• /pricing Smart Pricing

API (Backend · WIP)

• POST /api/v1/auth/register Register (email + password)
• POST /api/v1/auth/login Login (returns JWT)
• POST /api/v1/auth/logout Logout (invalidate session)
• GET /api/v1/auth/me Current user (Authorization: Bearer )

Backend scaffolding is present but still under active development (config loading, middleware wiring, migrations, etc.). Expect breaking changes while we iterate.

Getting Started

Backend (scaffold):

• Requirements: Go 1.19+, PostgreSQL
• Typical flow: cd backend && go mod tidy && go run bin/server/main.go
• Tests: cd backend && go test ./... (covers server wiring, migrate CLI, auth/games/rag handlers, config loaders, GitHub OAuth helpers)
• Notes: Config/credentials loading and server setup are WIP; DB DSN and environment wiring will be finalized in upcoming commits. See backend/README.md for the latest backend notes.

Core (Python RAG):

• Requirements: Python 3.11+, pip
• Install deps: cd core && python -m pip install --upgrade pip && python -m pip install ".[dev]"
• Lint: python -m ruff check .
• Format: python -m black .
• Tests: cd core && python -m pytest (tests stub the vector store/RAG chat so no OpenAI tokens are consumed)

Frontend (Vite):

Demo link: http://game.lucas-ty.com

• Local dev (no .env file):
  • cd frontend && npm install
  • export VITE_GITHUB_TOKEN=github_pat_xxx
  • export VITE_MODEL_ENDPOINT=https://models.github.ai/inference
  • export VITE_MODEL_ID=openai/gpt-4.1-mini
  • npm run dev then open http://localhost:5173
• Docker via Compose (recommended for dev):
  • export VITE_GITHUB_TOKEN=github_pat_xxx
  • docker compose -f docker/dev.docker-compose.yml up -d --build frontend
  • open http://localhost:5173

Usage Tips

• Pricing: start from category average, adjust by quality and content hours, and consider wishlist/Demo conversion and launch discounts.
• Release timing: avoid heavy sale windows and AAA launches; align with your audience rhythm and marketing beats (demo/preview/reviews).
• Platform rubric: convert requirements (fees/split/submission/assets/SDK/ratings) into a checklist to reduce back‑and‑forth.

Docker (Prod‑like)

• Compose file: docker/dev.docker-compose.yml
• Build images: docker compose -f docker/dev.docker-compose.yml build
• Start all: docker compose -f docker/dev.docker-compose.yml up -d
• Logs: docker compose -f docker/dev.docker-compose.yml logs -f <service>
• Health: docker compose -f docker/dev.docker-compose.yml ps
• Stop: docker compose -f docker/dev.docker-compose.yml down

Continuous Integration & Deployment

Every push or PR touching frontend/**, backend/**, or the workflow itself runs .github/workflows/deploy.yml, which enforces three CI jobs plus one CD job:

1. Lint (CI)

   • npm ci inside frontend/ followed by npm run lint (ESLint flat config).
   • go vet ./... after installing Go via actions/setup-go.
   • ruff check . inside core/ (Python lint) after installing dev dependencies.

2. Format (CI) (needs lint)

   • npm ci again (cache warm) then npm run format (Prettier 3 --write).
   • gofmt -w . auto-formats backend Go files.
   • black . keeps the Python RAG service formatted.
   • A final git diff guard fails if any formatter leaves new changes.

3. Test (CI) (needs format)

   • Fresh checkout, Go toolchain, then go test ./... to run backend unit/API tests (e.g., games handlers).
   • Python 3.11 environment plus python -m pytest inside core/ (tests stub the vector store/RAG chat, so no OpenAI tokens are consumed).
   • Node 20 + npm ci in frontend/; if a test script exists, npm test runs frontend tests.

4. Deploy to GKE (CD) (needs tests, main branch only)

   • Uses Pulumi projects under infra/pulumi/deploy_indie_images and infra/pulumi/deploy_indie_k8s to build/push Docker images and apply Kubernetes resources.
   • Authenticates to GCP via GCP_DEPLOYMENT_SA_KEY, configures Artifact Registry Docker auth, and logs Pulumi into a GCS state backend.
   • Reads secrets such as PULUMI_CONFIG_PASSPHRASE, VITE_GITHUB_TOKEN, ENV_DOCKER, and OPENAI_API_KEY to set Pulumi stack config (e.g., frontend GitHub token, OpenAI API key, service account emails).

All jobs run on ubuntu-latest, reuse cached Node/Go deps, and can be triggered manually via workflow_dispatch.

Services and ports:

• Frontend: host 5173 → container 80 (http://localhost:5173)
• Core: host 8001 → container 8001 (GET /rag/health)
• ChromaDB: host 8002 → container 8000 (GET /api/v1/heartbeat)
• Backend: host 8080 → container 8080 (GET /api/v1/rag/health)

Notes:

• Backend container runs DB migrations automatically before starting the server and uses config at /app/backend/config/local/service-config.yaml by default.
• To override backend config/credentials, set CONFIG_PATH/CREDENTIALS_PATH envs or mount your files read‑only and point the envs to the mounted paths.

Roadmap

• Frontend: connect real backend APIs, add build scripts and deploy config, i18n and accessibility.
• Backend: services for pricing/date recommendations, knowledge base for platform Q&A, audit logs, multi‑tenant projects/roles/rate limiting.
• Data: bring in competitive pricing, holidays/sales calendars, and events from reliable sources.

License

MIT — see LICENSE for details.