# Fork the repository on GitHub, then clone your fork
git clone https://github.com/YOUR_USERNAME/deadlock-modmanager.git
cd deadlock-modmanager

# Add the upstream repository
git remote add upstream https://github.com/stormix/deadlock-modmanager.git

# Install dependencies
pnpm install

# Set up the development environment
cp env.example .env
docker compose up -d
pnpm db:push

# Sync with upstream
git fetch upstream
git checkout main
git merge upstream/main

# Create a new feature branch
git checkout -b feature/your-feature-name
# or for bug fixes
git checkout -b fix/issue-description

# For React components
src/components/[ComponentName]/
├── index.tsx           # Main component
├── [ComponentName].tsx # Implementation (if complex)
├── types.ts           # Component-specific types
└── hooks.ts           # Component-specific hooks

# For API endpoints
src/routers/[feature]/
├── index.ts           # Router exports
├── handlers.ts        # Request handlers
├── validation.ts      # Request/response schemas
└── types.ts          # Feature-specific types

# For shared utilities
packages/shared/src/
├── utils/            # Utility functions
├── types/           # Shared type definitions
├── constants/       # Application constants
└── validators/      # Shared validation schemas

# Run all tests
pnpm test

# Run tests for specific packages
pnpm --filter desktop test
pnpm --filter api test

# Run tests in watch mode during development
pnpm test:watch

import { render, screen } from "@testing-library/react";
import { ModCard } from "./ModCard";

describe("ModCard", () => {
  it("displays mod information correctly", () => {
    const mockMod = {
      id: 1,
      name: "Test Mod",
      description: "A test mod",
      author: "Test Author",
    };

    render(<ModCard mod={mockMod} />);

    expect(screen.getByText("Test Mod")).toBeInTheDocument();
    expect(screen.getByText("Test Author")).toBeInTheDocument();
  });
});

import { test, expect } from "bun:test";
import { app } from "../src/index";

test("GET /api/mods returns mod list", async () => {
  const response = await app.request("/api/mods");
  const data = await response.json();

  expect(response.status).toBe(200);
  expect(Array.isArray(data.mods)).toBe(true);
});

# Run linting
pnpm lint

# Fix linting issues automatically
pnpm lint:fix

# Format code
pnpm format

# Type checking
pnpm check-types

# Run all quality checks
pnpm validate

# .lefthook.yml (configured automatically)
pre-commit:
  commands:
    format:
      run: pnpm format:fix
    lint:
      run: pnpm lint:fix
    types:
      run: pnpm check-types

<type>(<scope>): <description>

[optional body]

[optional footer]

feat(desktop): add mod search functionality
fix(api): handle pagination edge cases properly
docs(readme): update installation instructions
refactor(shared): extract common validation logic
test(desktop): add unit tests for mod installation
chore(deps): update Tauri to v2.1.0

# Sync with upstream
git fetch upstream main
git rebase upstream/main

# Run final checks
pnpm validate
pnpm build

# Push to your fork
git push origin feature/your-feature-name

feat(desktop): add advanced mod filtering options

## Description

Brief description of the changes and motivation.

## Type of Change

- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Documentation update

## Testing

- [ ] I have tested these changes locally
- [ ] I have added tests that prove my fix is effective or that my feature works
- [ ] New and existing unit tests pass locally with my changes

## Screenshots (if applicable)

Include screenshots of UI changes.

## Checklist

- [ ] My code follows the style guidelines of this project
- [ ] I have performed a self-review of my own code
- [ ] I have made corresponding changes to the documentation
- [ ] My changes generate no new warnings
- [ ] I have read and followed the contributing guidelines

# Make requested changes
git add .
git commit -m "fix: address review feedback"

# If you need to modify commit history
git rebase -i HEAD~n  # where n is number of commits to modify

# Push changes
git push origin feature/your-feature-name

// src/components/ModInstaller/ModInstaller.tsx
import { useState } from "react";
import { useMod } from "@/hooks/useMod";
import { Button } from "@/components/ui/Button";

interface ModInstallerProps {
  modId: string;
}

export function ModInstaller({ modId }: ModInstallerProps) {
  const [isInstalling, setIsInstalling] = useState(false);
  const { mod, installMod } = useMod(modId);

  const handleInstall = async () => {
    setIsInstalling(true);
    try {
      await installMod();
    } catch (error) {
      console.error("Installation failed:", error);
    } finally {
      setIsInstalling(false);
    }
  };

  return (
    <Button
      onClick={handleInstall}
      disabled={isInstalling}
      className="bg-primary text-primary-foreground"
    >
      {isInstalling ? "Installing..." : "Install"}
    </Button>
  );
}

// src/contexts/ModsContext.tsx
import { createContext, useContext, useReducer } from "react";
import type { Mod } from "@/types/mod";

interface ModsState {
  mods: Mod[];
  installedMods: Mod[];
  loading: boolean;
}

const ModsContext = createContext<ModsState | null>(null);

export function ModsProvider({ children }: { children: React.ReactNode }) {
  const [state, dispatch] = useReducer(modsReducer, initialState);

  return (
    <ModsContext.Provider value={{ ...state, dispatch }}>
      {children}
    </ModsContext.Provider>
  );
}

// src/routers/mods/handlers.ts
import { createRoute } from "@hono/zod-openapi";
import { z } from "zod";

const ModSchema = z.object({
  id: z.number(),
  name: z.string(),
  description: z.string(),
  author: z.string(),
});

export const getModsRoute = createRoute({
  method: "get",
  path: "/mods",
  request: {
    query: z.object({
      page: z.string().optional(),
      limit: z.string().optional(),
      search: z.string().optional(),
    }),
  },
  responses: {
    200: {
      content: {
        "application/json": {
          schema: z.object({
            mods: z.array(ModSchema),
            total: z.number(),
            page: z.number(),
            limit: z.number(),
          }),
        },
      },
      description: "List of mods",
    },
  },
});

export async function getMods(c: Context) {
  const { page = "1", limit = "20", search } = c.req.valid("query");

  const result = await modService.getMods({
    page: parseInt(page),
    limit: parseInt(limit),
    search,
  });

  return c.json(result);
}

# Generate a new migration
pnpm --filter database db:generate

# Example migration file

// packages/database/src/migrations/0001_add_mod_ratings.sql
CREATE TABLE mod_ratings (
  id SERIAL PRIMARY KEY,
  mod_id INTEGER REFERENCES mods(id) ON DELETE CASCADE,
  user_hash VARCHAR(64) NOT NULL,
  rating INTEGER CHECK (rating >= 1 AND rating <= 5),
  comment TEXT,
  created_at TIMESTAMP DEFAULT NOW(),
  UNIQUE(mod_id, user_hash)
);

CREATE INDEX idx_mod_ratings_mod_id ON mod_ratings(mod_id);
CREATE INDEX idx_mod_ratings_rating ON mod_ratings(rating DESC);

---
title: Your Page Title
description: Brief description of the page content
---

import { Card, Cards } from 'fumadocs-ui/components/card';
import { Callout } from 'fumadocs-ui/components/callout';

# Your Page Title

Content goes here...

<Callout type="info" title="Important Note">
Highlight important information with callouts.
</Callout>

## Next Steps

<Cards>
  <Card 
    title="Related Guide" 
    description="Link to related documentation"
    href="/path-to-guide" 
  />
</Cards>