feat(contacts): integrate contacts into Todo and Calendar apps

- Add ContactSelector, ContactBadge, ContactAvatar to shared-ui
- Add ContactsClient API service to shared-auth
- Add ContactReference, ContactSummary types to shared-types
- Todo: Add assignee and involvedContacts to tasks with UI in TaskEditModal
- Todo: Display contacts in TaskItem and KanbanTaskCard
- Calendar: Add AttendeeSelector with RSVP status support
- Calendar: Integrate attendees in EventForm
- Calendar: Add task drag-drop to calendar views (Day/Week/MultiDay)
- Contacts: Add ContactTasks component to show related tasks
- Backend: Add findByContact endpoint to Todo task service
- UI polish: glassmorphism styling, keyboard navigation, auto-focus

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

packages/shared-auth/src/clients/contactsClient.ts

@@ -0,0 +1,204 @@
+/**
+ * Contacts API Client for cross-app integration
+ *
+ * This client allows other apps (Todo, Calendar) to search and fetch contacts
+ * from the Contacts app backend.
+ */
+
+import type { ContactSummary } from '@manacore/shared-types';
+
+export interface ContactsClientConfig {
+	/** Base URL of the Contacts API (e.g., http://localhost:3015/api/v1) */
+	apiUrl: string;
+	/** Function to get the current auth token */
+	getAuthToken: () => Promise<string | null>;
+	/** Request timeout in ms (default: 5000) */
+	timeout?: number;
+}
+
+export interface ContactSearchOptions {
+	/** Search query string */
+	query?: string;
+	/** Maximum number of results */
+	limit?: number;
+	/** Skip archived contacts */
+	excludeArchived?: boolean;
+}
+
+/**
+ * Client for accessing the Contacts API from other apps
+ */
+export class ContactsClient {
+	private config: ContactsClientConfig;
+	private available: boolean | null = null;
+
+	constructor(config: ContactsClientConfig) {
+		this.config = {
+			timeout: 5000,
+			...config,
+		};
+	}
+
+	/**
+	 * Check if the Contacts API is available
+	 */
+	async isAvailable(): Promise<boolean> {
+		try {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+
+			const response = await fetch(`${this.config.apiUrl}/health`, {
+				method: 'GET',
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeoutId);
+			this.available = response.ok;
+			return this.available;
+		} catch {
+			this.available = false;
+			return false;
+		}
+	}
+
+	/**
+	 * Get cached availability status (call isAvailable() to refresh)
+	 */
+	getCachedAvailability(): boolean | null {
+		return this.available;
+	}
+
+	/**
+	 * Search contacts by query string
+	 */
+	async searchContacts(options: ContactSearchOptions = {}): Promise<ContactSummary[]> {
+		const { query = '', limit = 20, excludeArchived = true } = options;
+
+		const params = new URLSearchParams();
+		if (query) params.set('search', query);
+		if (limit) params.set('limit', String(limit));
+		if (excludeArchived) params.set('isArchived', 'false');
+
+		try {
+			const response = (await this.fetchWithAuth(`/contacts?${params.toString()}`)) as {
+				contacts?: Record<string, unknown>[];
+			};
+			return this.mapToContactSummaries(response.contacts || []);
+		} catch (error) {
+			console.error('[ContactsClient] Failed to search contacts:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * Get a single contact by ID
+	 */
+	async getContact(id: string): Promise<ContactSummary | null> {
+		try {
+			const response = (await this.fetchWithAuth(`/contacts/${id}`)) as {
+				contact?: Record<string, unknown>;
+			};
+			if (response.contact) {
+				return this.mapToContactSummary(response.contact);
+			}
+			return null;
+		} catch (error) {
+			console.error(`[ContactsClient] Failed to get contact ${id}:`, error);
+			return null;
+		}
+	}
+
+	/**
+	 * Get multiple contacts by IDs (batch fetch)
+	 */
+	async getContacts(ids: string[]): Promise<ContactSummary[]> {
+		if (ids.length === 0) return [];
+
+		// Contacts API doesn't have a batch endpoint, so we fetch individually
+		// but with Promise.allSettled to handle partial failures gracefully
+		const results = await Promise.allSettled(ids.map((id) => this.getContact(id)));
+
+		return results
+			.filter(
+				(result): result is PromiseFulfilledResult<ContactSummary | null> =>
+					result.status === 'fulfilled' && result.value !== null
+			)
+			.map((result) => result.value as ContactSummary);
+	}
+
+	/**
+	 * Internal fetch with auth token
+	 */
+	private async fetchWithAuth(endpoint: string, options: RequestInit = {}): Promise<unknown> {
+		const token = await this.config.getAuthToken();
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+
+		const headers: HeadersInit = {
+			'Content-Type': 'application/json',
+			...(options.headers || {}),
+		};
+
+		if (token) {
+			(headers as Record<string, string>)['Authorization'] = `Bearer ${token}`;
+		}
+
+		try {
+			const response = await fetch(`${this.config.apiUrl}${endpoint}`, {
+				...options,
+				headers,
+				signal: controller.signal,
+			});
+
+			clearTimeout(timeoutId);
+
+			if (!response.ok) {
+				const error = await response.json().catch(() => ({ message: 'Request failed' }));
+				throw new Error(error.message || `HTTP ${response.status}`);
+			}
+
+			return response.json();
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === 'AbortError') {
+				throw new Error('Request timeout');
+			}
+			throw error;
+		}
+	}
+
+	/**
+	 * Map API contact response to ContactSummary
+	 */
+	private mapToContactSummary(contact: Record<string, unknown>): ContactSummary {
+		return {
+			id: contact.id as string,
+			displayName:
+				(contact.displayName as string) ||
+				[contact.firstName, contact.lastName].filter(Boolean).join(' ') ||
+				(contact.email as string) ||
+				'Unbekannt',
+			firstName: contact.firstName as string | undefined,
+			lastName: contact.lastName as string | undefined,
+			email: contact.email as string | undefined,
+			phone: (contact.phone as string) || (contact.mobile as string) || undefined,
+			company: contact.company as string | undefined,
+			photoUrl: contact.photoUrl as string | undefined,
+		};
+	}
+
+	/**
+	 * Map array of contacts to ContactSummary[]
+	 */
+	private mapToContactSummaries(contacts: Record<string, unknown>[]): ContactSummary[] {
+		return contacts.map((c) => this.mapToContactSummary(c));
+	}
+}
+
+/**
+ * Create a ContactsClient instance
+ */
+export function createContactsClient(config: ContactsClientConfig): ContactsClient {
+	return new ContactsClient(config);
+}

packages/shared-auth/src/index.ts

@@ -70,6 +70,10 @@ export {
 } from './interceptors/fetchInterceptor';
 export type { FetchInterceptorConfig } from './interceptors/fetchInterceptor';
 
+// Contacts client for cross-app integration
+export { ContactsClient, createContactsClient } from './clients/contactsClient';
+export type { ContactsClientConfig, ContactSearchOptions } from './clients/contactsClient';
+
 /**
  * Initialize auth service with all adapters for web
  *