feat(m4): project & member management with tests and e2e

- ProjectRepository, ProjectMemberRepository, minimal NotificationRepository
- ProjectService: create/update/archive/delete project, add/remove member,
  permission checks (isMember/admin), member-added notification, getDashboard
  skeleton, getMyProjects, getMemberRole
- projectValidator, API services factory
- API routes: projects CRUD, members list/add/remove
- Screens: dashboard (project list + create form), project overview, members,
  settings; layout (Header/Sidebar/ProjectNav) and project components
- Unit tests (Project/ProjectMember repositories, ProjectService),
  integration project-member-permission, e2e project-management

tests/unit/repositories/ProjectMemberRepository.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createMigratedTestDb } from '@/tests/helpers/db';
+import type { SqliteDatabase } from '@/lib/db/sqlite';
+import { UserRepository } from '@/repositories/UserRepository';
+import { ProjectRepository } from '@/repositories/ProjectRepository';
+import { ProjectMemberRepository } from '@/repositories/ProjectMemberRepository';
+
+describe('ProjectMemberRepository', () => {
+  let db: SqliteDatabase;
+  let userRepo: UserRepository;
+  let projectRepo: ProjectRepository;
+  let repo: ProjectMemberRepository;
+  let ownerId: number;
+  let projectId: number;
+
+  beforeEach(() => {
+    db = createMigratedTestDb();
+    userRepo = new UserRepository(db);
+    projectRepo = new ProjectRepository(db);
+    repo = new ProjectMemberRepository(db);
+    ownerId = userRepo.create({
+      name: 'Owner',
+      email: 'owner@example.com',
+      passwordHash: 'h',
+    }).id;
+    projectId = projectRepo.create({ name: 'P', ownerId }).id;
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe('add / findByProject', () => {
+    it('adds a member and lists them with user info', () => {
+      repo.add(projectId, ownerId, 'admin');
+
+      const members = repo.findByProject(projectId);
+      expect(members).toHaveLength(1);
+      expect(members[0].userId).toBe(ownerId);
+      expect(members[0].role).toBe('admin');
+      expect(members[0].user.email).toBe('owner@example.com');
+    });
+
+    it('rejects adding the same member twice (UNIQUE constraint)', () => {
+      repo.add(projectId, ownerId, 'admin');
+      expect(() => repo.add(projectId, ownerId, 'member')).toThrow();
+    });
+  });
+
+  describe('isMember', () => {
+    it('returns true for a member and false otherwise', () => {
+      repo.add(projectId, ownerId, 'admin');
+
+      expect(repo.isMember(projectId, ownerId)).toBe(true);
+      expect(repo.isMember(projectId, 99999)).toBe(false);
+    });
+  });
+
+  describe('getRole', () => {
+    it('returns the role for a member', () => {
+      repo.add(projectId, ownerId, 'admin');
+
+      expect(repo.getRole(projectId, ownerId)).toBe('admin');
+    });
+
+    it('returns null for a non-member', () => {
+      expect(repo.getRole(projectId, 99999)).toBeNull();
+    });
+  });
+
+  describe('remove', () => {
+    it('removes a member and returns true', () => {
+      repo.add(projectId, ownerId, 'admin');
+
+      expect(repo.remove(projectId, ownerId)).toBe(true);
+      expect(repo.isMember(projectId, ownerId)).toBe(false);
+    });
+
+    it('returns false when the member does not exist', () => {
+      expect(repo.remove(projectId, 99999)).toBe(false);
+    });
+  });
+
+  describe('findByUser', () => {
+    it('returns memberships for a user across projects', () => {
+      const other = userRepo.create({
+        name: 'Other',
+        email: 'other@example.com',
+        passwordHash: 'h',
+      }).id;
+      const p2 = projectRepo.create({ name: 'P2', ownerId }).id;
+
+      repo.add(projectId, other, 'member');
+      repo.add(p2, other, 'admin');
+
+      const memberships = repo.findByUser(other);
+      expect(memberships).toHaveLength(2);
+    });
+  });
+});

tests/unit/repositories/ProjectRepository.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createMigratedTestDb } from '@/tests/helpers/db';
+import type { SqliteDatabase } from '@/lib/db/sqlite';
+import { UserRepository } from '@/repositories/UserRepository';
+import { ProjectRepository } from '@/repositories/ProjectRepository';
+import { ProjectMemberRepository } from '@/repositories/ProjectMemberRepository';
+
+describe('ProjectRepository', () => {
+  let db: SqliteDatabase;
+  let userRepo: UserRepository;
+  let repo: ProjectRepository;
+  let memberRepo: ProjectMemberRepository;
+  let ownerId: number;
+
+  beforeEach(() => {
+    db = createMigratedTestDb();
+    userRepo = new UserRepository(db);
+    repo = new ProjectRepository(db);
+    memberRepo = new ProjectMemberRepository(db);
+    ownerId = userRepo.create({
+      name: 'Owner',
+      email: 'owner@example.com',
+      passwordHash: 'h',
+    }).id;
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe('create', () => {
+    it('creates a project with active status and returns it', () => {
+      const project = repo.create({
+        name: 'Project A',
+        description: 'desc',
+        ownerId,
+      });
+
+      expect(project.id).toBeGreaterThan(0);
+      expect(project.name).toBe('Project A');
+      expect(project.description).toBe('desc');
+      expect(project.status).toBe('active');
+      expect(project.ownerId).toBe(ownerId);
+    });
+  });
+
+  describe('findById', () => {
+    it('returns the project when found', () => {
+      const created = repo.create({ name: 'P', ownerId });
+
+      expect(repo.findById(created.id)?.name).toBe('P');
+    });
+
+    it('returns null when not found', () => {
+      expect(repo.findById(99999)).toBeNull();
+    });
+  });
+
+  describe('findByOwner', () => {
+    it('returns projects owned by the user', () => {
+      repo.create({ name: 'P1', ownerId });
+      repo.create({ name: 'P2', ownerId });
+
+      const owned = repo.findByOwner(ownerId);
+      expect(owned).toHaveLength(2);
+    });
+  });
+
+  describe('findProjectsByUserId', () => {
+    it('returns only projects the user is a member of', () => {
+      const p1 = repo.create({ name: 'P1', ownerId });
+      const p2 = repo.create({ name: 'P2', ownerId });
+      const other = userRepo.create({
+        name: 'Other',
+        email: 'other@example.com',
+        passwordHash: 'h',
+      }).id;
+
+      memberRepo.add(p1.id, other, 'member');
+
+      const projects = repo.findProjectsByUserId(other);
+      expect(projects.map((p) => p.id)).toEqual([p1.id]);
+      expect(projects.map((p) => p.id)).not.toContain(p2.id);
+    });
+  });
+
+  describe('update', () => {
+    it('updates name, description and status', () => {
+      const created = repo.create({ name: 'P', ownerId });
+
+      const updated = repo.update(created.id, {
+        name: 'P2',
+        description: 'new desc',
+        status: 'archived',
+      });
+
+      expect(updated?.name).toBe('P2');
+      expect(updated?.description).toBe('new desc');
+      expect(updated?.status).toBe('archived');
+    });
+
+    it('returns null for a non-existent project', () => {
+      expect(repo.update(99999, { name: 'X' })).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('deletes the project and returns true', () => {
+      const created = repo.create({ name: 'P', ownerId });
+
+      expect(repo.delete(created.id)).toBe(true);
+      expect(repo.findById(created.id)).toBeNull();
+    });
+
+    it('returns false when the project does not exist', () => {
+      expect(repo.delete(99999)).toBe(false);
+    });
+  });
+});