chore: update justfile with SQLite acceptance tests and utility tasks

.gitea/WORKFLOW_ARCHITECTURE.md

@@ -0,0 +1,167 @@
+# Gitea Actions Workflow Architecture
+
+This document describes the workflow architecture for version bumping, testing, and releases.
+
+## Overview
+
+The workflow architecture uses a three-step process:
+1. **PR Workflow**: Runs tests on PRs and analyzes commits for bump type
+2. **Test Workflow**: Runs unit tests on all branch pushes (except version bumps)
+3. **Release Workflow**: Bumps version, creates tags, builds Docker images, and deploys on main branch pushes
+
+## Workflow Files
+
+### 1. `.gitea/workflows/pr.yml` (Pull Request Workflow)
+
+**Trigger**: Pull requests to `main` branch
+
+**Purpose**:
+- Run unit tests on every PR (fast feedback)
+- Run acceptance tests with SQLite database
+- Analyze commits to determine bump type (major/minor/patch)
+- Comment the suggested bump type on the PR
+
+**Test Execution**:
+- **Unit Tests**: Run first, fast execution
+- **Acceptance Tests**: Run after unit tests pass, uses SQLite database
+- **Database**: SQLite with `DATABASE_URL=file:./prisma/ci.db`
+- **Secrets**: Uses `BETTER_AUTH_SECRET` for authentication
+
+**Bump Type Detection**:
+- **Major**: Breaking changes detected (`BREAKING CHANGE` or `!:` in commit messages)
+- **Minor**: Feature commits detected (`feat:` prefix)
+- **Patch**: Default for fixes and other changes
+
+### 2. `.gitea/workflows/test.yml` (Test Workflow)
+
+**Trigger**: Pushes to any branch (including main)
+
+**Purpose**:
+- Run unit tests on all branch pushes
+- Skip auto-generated version bump commits (handled by release workflow)
+
+**Key Features**:
+- Runs on all branches including main
+- Skips commits with "chore: bump version" message
+- Fast execution for quick feedback
+
+### 3. `.gitea/workflows/release.yml` (Release Workflow)
+
+**Trigger**: Pushes to `main` branch (after PR merge)
+
+**Purpose**:
+- Determine bump type from merge commit or PR commits
+- Bump version in `package.json` and `CHANGELOG.md`
+- Commit the version bump
+- Create git tag for the release
+- Run tests inside Docker container (with PostgreSQL)
+- Build production Docker image
+- Push images to registry
+- Deploy to dev environment
+
+**Key Features**:
+- Skips commits that are auto-generated version bumps
+- Uses `DOCKER_LOGIN` and `DOCKER_PASSWORD` secrets for registry auth
+- Handles existing git tags gracefully
+- Runs comprehensive tests in production-like environment
+
+## Version Bump Logic
+
+### Step 1: PR Analysis (pr.yml)
+When a PR is opened or updated:
+1. Fetch the merge base with `main`
+2. Analyze all commits in the PR
+3. Determine bump type based on commit messages:
+   - Breaking changes → major
+   - Features → minor
+   - Fixes → patch
+4. Comment the suggested bump type on the PR
+
+### Step 2: Release (release.yml)
+When a PR is merged to `main`:
+1. Check if the commit is an auto-bump (skip if so)
+2. Analyze the merge commit message or PR commits
+3. Run `node scripts/bump-version.js <type> --yes`
+4. Commit the version bump changes
+5. Create and push git tag
+6. Build and push Docker images
+
+## Environment Variables & Secrets
+
+### Required Secrets
+- `DOCKER_LOGIN`: Username for Docker registry authentication
+- `DOCKER_PASSWORD`: Password for Docker registry authentication
+- `GITEA_TOKEN` (optional): For pushing back to repo (if needed)
+
+### Environment Variables
+- `REGISTRY`: Docker registry URL (default: `docker.notsosm.art`)
+- `IMAGE_NAME`: Docker image name (default: `euchre-camp`)
+
+## Example Workflow
+
+### Scenario: Feature PR
+1. Developer opens PR with commits:
+   - "feat: add new feature"
+   - "fix: resolve edge case"
+2. PR workflow runs:
+   - Unit tests pass
+   - Bump type analysis suggests "minor"
+   - Comment posted on PR: "Suggested bump: MINOR"
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects minor bump from commits
+   - Bumps version from 0.1.1 → 0.2.0
+   - Commits version bump
+   - Creates tag v0.2.0
+   - Builds and pushes Docker image
+   - Deploys to dev
+
+### Scenario: Breaking Change PR
+1. Developer opens PR with commit:
+   - "feat!: breaking API change"
+2. PR workflow runs:
+   - Detects breaking change marker
+   - Suggests "major" bump
+   - Comments on PR
+3. Developer merges PR
+4. Release workflow runs:
+   - Detects major bump
+   - Bumps version from 0.1.1 → 1.0.0
+   - Creates tag v1.0.0
+   - Proceeds with build and deploy
+
+## Database Configuration for CI
+
+### SQLite for CI Acceptance Tests
+- **Why SQLite**: No database server required, perfect for CI environments
+- **Usage**: PR workflow runs acceptance tests with SQLite database
+- **Configuration**: `DATABASE_PROVIDER=sqlite`, `DATABASE_URL=file:./prisma/ci.db`
+- **Benefits**: Fast, isolated, no external dependencies
+
+### PostgreSQL for Production
+- **Usage**: Release workflow runs tests in Docker with PostgreSQL
+- **Configuration**: Uses dummy PostgreSQL URL for Docker builds
+- **Benefits**: Production-like environment, catches PostgreSQL-specific issues
+
+### Database Provider Detection
+The application automatically detects the database provider:
+- `DATABASE_PROVIDER` environment variable (defaults to `sqlite`)
+- `prisma.ts` conditionally uses PrismaPg adapter for PostgreSQL
+- Better Auth configured with appropriate provider
+
+## Benefits
+
+1. **No CI Loops**: Version bump commits are detected and skipped
+2. **Clear Communication**: PR comments inform developers of impact
+3. **Semantic Versioning**: Automated adherence to semver rules
+4. **Traceability**: Git tags and changelog reflect all changes
+5. **Safe Releases**: Tests run before version bump and deployment
+6. **Fast CI**: SQLite tests run quickly without database server setup
+7. **Comprehensive Testing**: Both unit and acceptance tests in PR workflow
+
+## Future Enhancements
+
+- Add GitHub/Gitea Release creation
+- Slack/Discord notifications on release
+- Automatic rollback on test failure
+- Multi-environment deployment (dev/staging/prod)

.gitea/workflows/pr.yml

@@ -0,0 +1,127 @@
+name: Pull Request
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run unit tests
+        run: npm run test:run
+
+  acceptance-tests:
+    runs-on: ubuntu-latest
+    needs: unit-tests
+    env:
+      DATABASE_PROVIDER: sqlite
+      DATABASE_URL: file:./prisma/ci.db
+      BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Generate Prisma client
+        run: npx prisma generate
+
+      - name: Setup SQLite database
+        run: |
+          # Create SQLite database file
+          mkdir -p prisma
+          npx prisma migrate deploy
+
+      - name: Run acceptance tests
+        run: npm run test:acceptance
+        env:
+          DATABASE_PROVIDER: sqlite
+          DATABASE_URL: file:./prisma/ci.db
+          BETTER_AUTH_SECRET: test-secret-key-for-ci-only
+
+  analyze-bump-type:
+    runs-on: ubuntu-latest
+    needs: acceptance-tests
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Analyze commits for bump type
+        id: bump_type
+        run: |
+          # Get the merge base and PR commits
+          git fetch origin main:main 2>/dev/null || true
+          MERGE_BASE=$(git merge-base HEAD main 2>/dev/null || echo "HEAD~1")
+
+          # Analyze commits in this PR
+          COMMITS=$(git log --oneline ${MERGE_BASE}..HEAD 2>/dev/null || git log --oneline -10)
+
+          echo "Commits in this PR:"
+          echo "$COMMITS"
+          echo ""
+
+          # Determine bump type
+          if echo "$COMMITS" | grep -qE "(BREAKING CHANGE|!:)"; then
+            BUMP="major"
+            REASON="Breaking change detected in commit messages"
+          elif echo "$COMMITS" | grep -qE "^feat"; then
+            BUMP="minor"
+            REASON="Feature commits detected"
+          else
+            BUMP="patch"
+            REASON="Defaulting to patch (fixes or other changes)"
+          fi
+
+          echo "Suggested bump type: $BUMP"
+          echo "Reason: $REASON"
+          echo "bump=$BUMP" >> $GITHUB_OUTPUT
+          echo "reason=$REASON" >> $GITHUB_OUTPUT
+
+      - name: Comment bump type on PR
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const bump = '${{ steps.bump_type.outputs.bump }}';
+            const reason = '${{ steps.bump_type.outputs.reason }}';
+
+            const comment = `
+            ## 🏷️ Version Bump Analysis
+
+            **Suggested bump type:** \`${bump.toUpperCase()}\`
+            **Reason:** ${reason}
+
+            This PR will bump the version to the next ${bump} version when merged.
+            `;
+
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });

.gitea/workflows/release.yml

@@ -10,8 +10,9 @@ env:
   IMAGE_NAME: euchre-camp
 
 jobs:
-  build-and-test:
+  release:
     runs-on: ubuntu-latest
+    # Skip if this is an auto-generated version bump commit
     if: "!contains(github.event.head_commit.message, 'chore: bump version')"
 
     steps:
@@ -19,14 +20,75 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN || github.token }}
 
-      - name: Get current version
+      - name: Configure Git
+        run: |
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.com"
+
+      - name: Determine version bump type
+        id: bump_type
+        run: |
+          # Get the merge commit message or use commits since last tag
+          MERGE_MSG="${{ github.event.head_commit.message }}"
+          echo "Commit message: $MERGE_MSG"
+
+          # Determine bump type from commit message or commits
+          if echo "$MERGE_MSG" | grep -qE "(BREAKING CHANGE|!:)"; then
+            echo "bump=major" >> $GITHUB_OUTPUT
+            echo "Bump type: major (breaking change detected)"
+          elif echo "$MERGE_MSG" | grep -qE "^feat"; then
+            echo "bump=minor" >> $GITHUB_OUTPUT
+            echo "Bump type: minor (feature detected)"
+          else
+            # Check actual commits in the PR
+            LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+            if [ -n "$LAST_TAG" ]; then
+              COMMITS=$(git log --oneline ${LAST_TAG}..HEAD 2>/dev/null | head -5)
+            else
+              COMMITS=$(git log --oneline | head -5)
+            fi
+            echo "Recent commits: $COMMITS"
+
+            if echo "$COMMITS" | grep -qE "BREAKING\|!:"; then
+              echo "bump=major" >> $GITHUB_OUTPUT
+              echo "Bump type: major (breaking change in commits)"
+            elif echo "$COMMITS" | grep -qE "^feat"; then
+              echo "bump=minor" >> $GITHUB_OUTPUT
+              echo "Bump type: minor (feature in commits)"
+            else
+              echo "bump=patch" >> $GITHUB_OUTPUT
+              echo "Bump type: patch (default)"
+            fi
+          fi
+
+      - name: Bump version
         id: version
         run: |
-          # Read version from package.json
+          BUMP="${{ steps.bump_type.outputs.bump }}"
-          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          echo "Bumping version: $BUMP"
-          echo "version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
-          echo "Current version: $CURRENT_VERSION"
+          # Run the bump script
+          node scripts/bump-version.js "$BUMP" --yes
+
+          # Get new version
+          NEW_VERSION=$(node -p "require('./package.json').version")
+          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          echo "New version: $NEW_VERSION"
+
+      - name: Commit version bump
+        run: |
+          git add package.json CHANGELOG.md
+          git commit -m "chore: bump version to v${{ steps.version.outputs.new_version }}"
+          git push origin main
+
+      - name: Create git tag for release
+        run: |
+          TAG_NAME="v${{ steps.version.outputs.new_version }}"
+          echo "Creating tag $TAG_NAME"
+          git tag -a "$TAG_NAME" -m "Release $TAG_NAME"
+          git push origin "$TAG_NAME"
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
@@ -36,14 +98,14 @@ jobs:
           docker build \
             --target test-runner \
             --build-arg GIT_COMMIT=${{ github.sha }} \
-            -t ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.version }} \
+            -t ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
             .
 
       - name: Run tests inside test-capable container
         run: |
           docker run --rm \
             -e DATABASE_URL="postgresql://user:pass@localhost:5432/dummy" \
-            ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.version }} \
+            ${{ env.IMAGE_NAME }}-test:${{ steps.version.outputs.new_version }} \
             npm run test:run
 
       - name: Build production image
@@ -51,37 +113,35 @@ jobs:
           docker build \
             --target runner \
             --build-arg GIT_COMMIT=${{ github.sha }} \
-            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.version }} \
+            -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }} \
             -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest \
             .
 
-      - name: Configure Git
-        run: |
-          git config user.name "Gitea Actions"
-          git config user.email "actions@gitea.com"
-
-      - name: Create git tag for release
-        run: |
-          git tag -a "v${{ steps.version.outputs.version }}" -m "Release v${{ steps.version.outputs.version }}"
-          git push origin "v${{ steps.version.outputs.version }}"
-
       - name: Push Docker images
         run: |
           echo "Pushing to ${{ env.REGISTRY }}..."
-          # Check if we can authenticate to the registry
+          # Check if we can authenticate to the registry using DOCKER_LOGIN and DOCKER_PASSWORD secrets
-          if docker login ${{ env.REGISTRY }} -u ${{ secrets.DOCKER_USERNAME }} -p ${{ secrets.DOCKER_PASSWORD }} 2>/dev/null; then
+          if [ -n "${{ secrets.DOCKER_LOGIN }}" ] && [ -n "${{ secrets.DOCKER_PASSWORD }}" ]; then
-            docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.version }}
+            if docker login ${{ env.REGISTRY }} -u ${{ secrets.DOCKER_LOGIN }} -p ${{ secrets.DOCKER_PASSWORD }} 2>/dev/null; then
+              docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}
               docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
               echo "Successfully pushed images to ${{ env.REGISTRY }}"
             else
-            echo "Warning: Could not authenticate to ${{ env.REGISTRY }}"
+              echo "Warning: Docker login failed with provided credentials"
               echo "Images built locally but not pushed to registry"
               echo "Manual push required:"
-            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.version }}"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
+              echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
+            fi
+          else
+            echo "Warning: DOCKER_LOGIN or DOCKER_PASSWORD secrets not configured"
+            echo "Images built locally but not pushed to registry"
+            echo "Manual push required:"
+            echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.new_version }}"
             echo "  docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"
           fi
 
       - name: Deploy to dev (placeholder)
         run: |
-          echo "Deploying version ${{ steps.version.outputs.version }} to dev environment..."
+          echo "Deploying version ${{ steps.version.outputs.new_version }} to dev environment..."
           # TODO: Add actual deployment steps

.gitea/workflows/test.yml

@@ -4,14 +4,12 @@ on:
   push:
     branches:
       - '**'
-      - '!main'  # Skip main branch (release workflow handles that)
-  pull_request:
-    branches:
-      - main
 
 jobs:
   unit-tests:
     runs-on: ubuntu-latest
+    # Skip if this is an auto-generated version bump commit (handled by release workflow)
+    if: "!contains(github.event.head_commit.message, 'chore: bump version')"
 
     steps:
       - name: Checkout code
@@ -28,28 +26,3 @@ jobs:
 
       - name: Run unit tests
         run: npm run test:run
-
-  # Acceptance tests that don't require DB read/write
-  # Only run on pull requests to main
-  safe-acceptance-tests:
-    runs-on: ubuntu-latest
-    needs: unit-tests
-    if: github.event_name == 'pull_request'
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Run safe acceptance tests
-        # These tests should not read/write to the database
-        # They might test UI components, routing, or static content
-        run: npm run test:acceptance -- --grep "safe|static|ui|component"

CHANGELOG.md

@@ -1,3 +1,22 @@
+## [0.1.2] - 2026-04-01
+
+### Patch Changes
+
+- fix: handle Docker registry authentication gracefully in release workflow
+- fix: run unit tests on branch commits, skip main branch
+- feat: add test workflow for every commit
+- trigger: release with test-capable image
+- feat: build test-capable image, run tests, then build production image
+- trigger: release workflow
+- fix: release workflow should not commit, only tag
+- trigger: manual workflow trigger for docker.notsosm.art
+- fix: update Docker build script to use docker.notsosm.art registry
+- fix: update workflow to use docker.notsosm.art registry
+- trigger: manual workflow trigger
+- fix: update workflow to use correct Docker registries
+- feat: add Gitea Actions release workflow
+- feat: add view match link to admin matches page
+
 ## [0.1.1] - 2026-04-01
 
 ### Patch Changes

justfile

@@ -9,8 +9,8 @@ set positional-arguments
 # Project name
 PROJECT := "euchre-camp"
 
-# Docker registry (CasaOS local registry)
+# Docker registry
-REGISTRY := "euchre-camp"  # Update to your registry host if needed
+REGISTRY := "docker.notsosm.art"
 IMAGE_TAG := "latest"
 
 # Get git commit hash (short version)
@@ -22,6 +22,8 @@ IMAGE_TAG_COMMIT := `git rev-parse --short HEAD`
 # --- Variables ---
 # Database
 DB_CONTAINER := "euchre-camp-postgres"
+DATABASE_PROVIDER := env_var_or_default("DATABASE_PROVIDER", "sqlite")
+DATABASE_URL := env_var_or_default("DATABASE_URL", "file:./prisma/dev.db")
 
 # --- Setup & Installation ---
 
@@ -54,15 +56,23 @@ format:
 
 # --- Testing ---
 
-# Run all tests (unit + acceptance)
+# Run all tests (unit + acceptance with SQLite)
-test: test-unit test-acceptance
+test: test-unit test-acceptance-sqlite
+
+# Run all tests with PostgreSQL (Docker)
+test-pg: test-unit test-acceptance-postgres
 
 # Run unit tests (Vitest)
 test-unit:
     npm run test:run
 
-# Run acceptance tests (Playwright)
+# Run acceptance tests with SQLite (fast, no Docker needed)
-test-acceptance:
+test-acceptance-sqlite:
+    @echo "Running acceptance tests with SQLite..."
+    DATABASE_PROVIDER=sqlite DATABASE_URL=file:./prisma/ci.db BETTER_AUTH_SECRET=test-secret-key npm run test:acceptance
+
+# Run acceptance tests with PostgreSQL (Docker)
+test-acceptance-postgres:
     @echo "Starting Docker containers for acceptance tests..."
     docker compose up -d
     @echo "Waiting for services to be ready..."
@@ -80,6 +90,13 @@ migrate:
 seed:
     npm run db:seed
 
+# Switch database provider
+db-switch-sqlite:
+    npm run db:switch sqlite
+
+db-switch-postgres:
+    npm run db:switch postgresql
+
 # --- Docker ---
 
 # Build the Docker image (standard build)
@@ -143,9 +160,18 @@ docker-push: docker-build-full
 # --- CI/CD Pipeline Simulation ---
 
 # Run full CI pipeline locally (lint, test, build, push)
-ci: lint typecheck test-unit docker-build
+# Matches the Gitea Actions workflow
+ci: lint typecheck test-unit test-acceptance-sqlite docker-build
     @echo "CI Pipeline completed successfully!"
 
+# PR validation (what runs on pull requests)
+pr-validate: lint typecheck test-unit test-acceptance-sqlite
+    @echo "PR validation completed successfully!"
+
+# Run CI with PostgreSQL (for release workflow simulation)
+ci-postgres: lint typecheck test-unit test-acceptance-postgres docker-build
+    @echo "CI Pipeline with PostgreSQL completed successfully!"
+
 # --- Utilities ---
 
 # Show help information
@@ -158,3 +184,72 @@ clean:
     rm -rf node_modules .next dist
     @echo "Cleaning Docker artifacts..."
     docker system prune -f
+
+# Generate Prisma client
+prisma-generate:
+    npx prisma generate
+
+# Reset development database
+db-reset-dev:
+    npm run db:reset-dev
+
+# Setup development database
+db-setup-dev:
+    npm run db:setup-dev
+
+# Clean production database (remove test records)
+db-clean-prod:
+    npm run db:cleanup-prod
+
+# Check production database for test records
+db-check-prod:
+    npm run db:check-prod
+
+# Create admin user
+admin-create:
+    node scripts/create-admin-via-api.js
+
+# List all users
+users-list:
+    node scripts/list-users.js
+
+# Update admin password
+admin-update-password:
+    node scripts/update-admin-password.js
+
+# Bump version
+version-bump-patch:
+    npm run version:patch
+
+version-bump-minor:
+    npm run version:minor
+
+version-bump-major:
+    npm run version:major
+
+# Docker Compose shortcuts
+docker-up:
+    npm run docker:up
+
+docker-down:
+    npm run docker:down
+
+docker-logs:
+    npm run docker:logs
+
+# View workflow status
+workflow-status:
+    @echo "Current workflows in .gitea/workflows/:"
+    ls -la .gitea/workflows/
+    @echo ""
+    @echo "PR Workflow: Runs unit + acceptance tests on pull requests"
+    @echo "Test Workflow: Runs unit tests on all branch pushes"
+    @echo "Release Workflow: Runs on main branch pushes (version bump + Docker build)"
+
+# Check current database provider
+db-status:
+    @echo "Database Provider: ${DATABASE_PROVIDER}"
+    @echo "Database URL: ${DATABASE_URL}"
+    @echo ""
+    @echo "Current schema.prisma provider:"
+    grep -A 2 "datasource db" prisma/schema.prisma | head -3

package.json

@@ -1,6 +1,6 @@
 {
   "name": "euchre_camp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": true,
   "scripts": {
     "dev": "NEXT_PUBLIC_GIT_COMMIT=$(git rev-parse --short HEAD) next dev",

scripts/bump-version.js

@@ -17,6 +17,7 @@ const path = require('path');
 // Parse command line arguments
 const args = process.argv.slice(2);
 const forcedVersion = args[0]; // e.g., "0.2.0" or "patch/minor/major"
+const skipConfirm = args.includes('--yes') || args.includes('-y'); // Skip confirmation prompt
 
 // Paths
 const packageJsonPath = path.join(__dirname, '..', 'package.json');

src/lib/prisma.ts

@@ -1,6 +1,4 @@
 import { PrismaClient } from '@prisma/client'
-import { PrismaPg } from '@prisma/adapter-pg'
-import pg from 'pg'
 import dotenv from 'dotenv'
 
 // Load .env file if it exists
@@ -10,11 +8,24 @@ const globalForPrisma = globalThis as unknown as {
   prisma: PrismaClient | undefined
 }
 
-const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+// Detect database provider from environment (default to sqlite for local development)
+const databaseProvider = process.env.DATABASE_PROVIDER || 'sqlite'
 
-// Create PrismaClient with adapter
+// Create PrismaClient with appropriate adapter
 const createPrismaClient = () => {
-  const client = new PrismaClient({ adapter })
+  let client: PrismaClient
+  
+  if (databaseProvider === 'postgresql') {
+    // Use PrismaPg adapter for PostgreSQL
+    const { PrismaPg } = require('@prisma/adapter-pg')
+    const pg = require('pg')
+    const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+    client = new PrismaClient({ adapter })
+  } else {
+    // No adapter needed for SQLite
+    client = new PrismaClient()
+  }
+  
   return client
 }