implement backend skeleton with MongoDB and Claude AI integration

- Add controllers (Auth, Chat, Event) with placeholder implementations
- Add services (Auth, Chat, Event) with business logic interfaces
- Add repositories with MongoDB/Mongoose models (User, Event, Chat)
- Add middleware for JWT authentication
- Add Claude AI adapter implementing AIProvider interface
- Add utility modules for JWT and password handling
- Add shared types and DTOs for User, CalendarEvent, ChatMessage
- Configure routes with proper endpoint structure
- Update app.ts with dependency injection setup
- Add required dependencies: mongoose, bcrypt, jsonwebtoken, @anthropic-ai/sdk

apps/server/src/services/AuthService.ts

@@ -0,0 +1,24 @@
+import { User, CreateUserDTO, LoginDTO, AuthResponse } from '@caldav/shared';
+import { UserRepository } from './interfaces';
+import * as jwt from '../utils/jwt';
+import * as password from '../utils/password';
+
+export class AuthService {
+  constructor(private userRepo: UserRepository) {}
+
+  async login(data: LoginDTO): Promise<AuthResponse> {
+    throw new Error('Not implemented');
+  }
+
+  async register(data: CreateUserDTO): Promise<AuthResponse> {
+    throw new Error('Not implemented');
+  }
+
+  async refreshToken(refreshToken: string): Promise<AuthResponse> {
+    throw new Error('Not implemented');
+  }
+
+  async logout(userId: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+}

apps/server/src/services/ChatService.ts

@@ -0,0 +1,30 @@
+import { ChatMessage, ChatResponse, SendMessageDTO, CalendarEvent, ConversationSummary, GetMessagesOptions } from '@caldav/shared';
+import { ChatRepository, EventRepository, AIProvider } from './interfaces';
+
+export class ChatService {
+  constructor(
+    private chatRepo: ChatRepository,
+    private eventRepo: EventRepository,
+    private aiProvider: AIProvider
+  ) {}
+
+  async processMessage(userId: string, data: SendMessageDTO): Promise<ChatResponse> {
+    throw new Error('Not implemented');
+  }
+
+  async confirmEvent(userId: string, conversationId: string, messageId: string): Promise<CalendarEvent> {
+    throw new Error('Not implemented');
+  }
+
+  async rejectEvent(conversationId: string, messageId: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  async getConversations(userId: string): Promise<ConversationSummary[]> {
+    throw new Error('Not implemented');
+  }
+
+  async getConversation(userId: string, conversationId: string, options?: GetMessagesOptions): Promise<ChatMessage[]> {
+    throw new Error('Not implemented');
+  }
+}

apps/server/src/services/EventService.ts

@@ -0,0 +1,30 @@
+import { CalendarEvent, CreateEventDTO, UpdateEventDTO } from '@caldav/shared';
+import { EventRepository } from './interfaces';
+
+export class EventService {
+  constructor(private eventRepo: EventRepository) {}
+
+  async create(userId: string, data: CreateEventDTO): Promise<CalendarEvent> {
+    throw new Error('Not implemented');
+  }
+
+  async getById(id: string, userId: string): Promise<CalendarEvent | null> {
+    throw new Error('Not implemented');
+  }
+
+  async getAll(userId: string): Promise<CalendarEvent[]> {
+    throw new Error('Not implemented');
+  }
+
+  async getByDateRange(userId: string, startDate: Date, endDate: Date): Promise<CalendarEvent[]> {
+    throw new Error('Not implemented');
+  }
+
+  async update(id: string, userId: string, data: UpdateEventDTO): Promise<CalendarEvent | null> {
+    throw new Error('Not implemented');
+  }
+
+  async delete(id: string, userId: string): Promise<boolean> {
+    throw new Error('Not implemented');
+  }
+}

apps/server/src/services/index.ts

@@ -0,0 +1,4 @@
+export * from './AuthService';
+export * from './ChatService';
+export * from './EventService';
+export * from './interfaces';

apps/server/src/services/interfaces/AIProvider.ts

@@ -0,0 +1,16 @@
+import { CalendarEvent, ChatMessage, CreateEventDTO } from '@caldav/shared';
+
+export interface AIContext {
+  userId: string;
+  conversationHistory: ChatMessage[];
+  existingEvents: CalendarEvent[];
+}
+
+export interface AIResponse {
+  content: string;
+  proposedEvent?: CreateEventDTO;
+}
+
+export interface AIProvider {
+  processMessage(message: string, context: AIContext): Promise<AIResponse>;
+}

apps/server/src/services/interfaces/ChatRepository.ts

@@ -0,0 +1,11 @@
+import { ChatMessage, Conversation, CreateMessageDTO, GetMessagesOptions } from '@caldav/shared';
+
+export interface ChatRepository {
+  // Conversations
+  getConversationsByUser(userId: string): Promise<Conversation[]>;
+  createConversation(userId: string): Promise<Conversation>;
+
+  // Messages (cursor-based pagination)
+  getMessages(conversationId: string, options?: GetMessagesOptions): Promise<ChatMessage[]>;
+  createMessage(conversationId: string, message: CreateMessageDTO): Promise<ChatMessage>;
+}

apps/server/src/services/interfaces/EventRepository.ts

@@ -0,0 +1,10 @@
+import { CalendarEvent, CreateEventDTO, UpdateEventDTO } from '@caldav/shared';
+
+export interface EventRepository {
+  findById(id: string): Promise<CalendarEvent | null>;
+  findByUserId(userId: string): Promise<CalendarEvent[]>;
+  findByDateRange(userId: string, startDate: Date, endDate: Date): Promise<CalendarEvent[]>;
+  create(userId: string, data: CreateEventDTO): Promise<CalendarEvent>;
+  update(id: string, data: UpdateEventDTO): Promise<CalendarEvent | null>;
+  delete(id: string): Promise<boolean>;
+}

apps/server/src/services/interfaces/UserRepository.ts

@@ -0,0 +1,13 @@
+import { User } from '@caldav/shared';
+
+export interface CreateUserData {
+  email: string;
+  displayName: string;
+  passwordHash: string;
+}
+
+export interface UserRepository {
+  findById(id: string): Promise<User | null>;
+  findByEmail(email: string): Promise<User | null>;
+  create(data: CreateUserData): Promise<User>;
+}

apps/server/src/services/interfaces/index.ts

@@ -0,0 +1,4 @@
+export * from './AIProvider';
+export * from './UserRepository';
+export * from './EventRepository';
+export * from './ChatRepository';