- @for (platform of platformOptions; track platform.value) {
-
- @if (!platform.available) {
-
- Coming Soon
-
- }
+
+
-
-
-
-
-
-
{{ platform.label }}
-
{{ platform.description }}
-
-
-
- }
-
+
+
@if (form().get('meetingTool')?.errors?.['required'] && form().get('meetingTool')?.touched) {
Please select a meeting platform
diff --git a/apps/lfx-pcc/src/app/modules/project/meetings/components/meeting-platform-features/meeting-platform-features.component.ts b/apps/lfx-pcc/src/app/modules/project/meetings/components/meeting-platform-features/meeting-platform-features.component.ts
index 7d3df46d..83397d44 100644
--- a/apps/lfx-pcc/src/app/modules/project/meetings/components/meeting-platform-features/meeting-platform-features.component.ts
+++ b/apps/lfx-pcc/src/app/modules/project/meetings/components/meeting-platform-features/meeting-platform-features.component.ts
@@ -2,7 +2,8 @@
// SPDX-License-Identifier: MIT
import { CommonModule } from '@angular/common';
-import { Component, input } from '@angular/core';
+import { Component, DestroyRef, inject, input, OnInit } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { FormGroup, ReactiveFormsModule } from '@angular/forms';
import { SelectComponent } from '@components/select/select.component';
import { ToggleComponent } from '@components/toggle/toggle.component';
@@ -15,7 +16,8 @@ import { TooltipModule } from 'primeng/tooltip';
imports: [CommonModule, ReactiveFormsModule, SelectComponent, ToggleComponent, TooltipModule],
templateUrl: './meeting-platform-features.component.html',
})
-export class MeetingPlatformFeaturesComponent {
+export class MeetingPlatformFeaturesComponent implements OnInit {
+ private readonly destroyRef = inject(DestroyRef);
// Form group input from parent
public readonly form = input.required
();
@@ -25,11 +27,39 @@ export class MeetingPlatformFeaturesComponent {
public readonly recordingAccessOptions = RECORDING_ACCESS_OPTIONS;
public readonly aiSummaryAccessOptions = AI_SUMMARY_ACCESS_OPTIONS;
- public selectPlatform(platform: string): void {
- const platformOption = this.platformOptions.find((p) => p.value === platform);
- if (platformOption?.available) {
- this.form().get('meetingTool')?.setValue(platform);
- }
+ // Transform platforms into dropdown options (only available platforms)
+ public readonly platformDropdownOptions = MEETING_PLATFORMS.map((platform) => ({
+ label: platform.available ? platform.label : `${platform.label} (Coming Soon)`,
+ value: platform.value,
+ icon: platform.icon,
+ description: platform.description,
+ disabled: !platform.available,
+ }));
+
+ public ngOnInit(): void {
+ // Watch for recording_enabled changes to disable dependent features
+ this.form()
+ .get('recording_enabled')
+ ?.valueChanges.pipe(takeUntilDestroyed(this.destroyRef))
+ .subscribe((recordingEnabled: boolean) => {
+ const dependentControls = ['transcripts_enabled', 'zoom_ai_enabled', 'youtube_enabled'];
+
+ dependentControls.forEach((controlName) => {
+ const control = this.form().get(controlName);
+ if (control) {
+ if (!recordingEnabled) {
+ // Disable and reset dependent features when recording is disabled
+ control.setValue(false);
+ control.disable();
+ } else {
+ // Re-enable dependent features when recording is enabled
+ control.enable();
+ }
+
+ control.updateValueAndValidity();
+ }
+ });
+ });
}
public toggleFeature(featureKey: string, enabled: boolean): void {
diff --git a/apps/lfx-pcc/src/app/modules/project/meetings/meeting-dashboard/meeting-dashboard.component.ts b/apps/lfx-pcc/src/app/modules/project/meetings/meeting-dashboard/meeting-dashboard.component.ts
index 73326ab5..516b88bd 100644
--- a/apps/lfx-pcc/src/app/modules/project/meetings/meeting-dashboard/meeting-dashboard.component.ts
+++ b/apps/lfx-pcc/src/app/modules/project/meetings/meeting-dashboard/meeting-dashboard.component.ts
@@ -261,7 +261,7 @@ export class MeetingDashboardComponent {
const project = this.project();
return [
{
- label: 'Schedule Meeting',
+ label: 'Create Meeting',
icon: 'fa-light fa-calendar-plus text-sm',
routerLink: project ? `/project/${project.slug}/meetings/create` : '#',
},
diff --git a/apps/lfx-pcc/src/app/shared/components/textarea/textarea.component.ts b/apps/lfx-pcc/src/app/shared/components/textarea/textarea.component.ts
index 360deea8..f5b31441 100644
--- a/apps/lfx-pcc/src/app/shared/components/textarea/textarea.component.ts
+++ b/apps/lfx-pcc/src/app/shared/components/textarea/textarea.component.ts
@@ -21,7 +21,7 @@ export class TextareaComponent {
public id = input();
public readonly = input(false);
public styleClass = input();
- public autoResize = input(true);
+ public autoResize = input(false);
public maxlength = input();
public dataTest = input();
}
diff --git a/apps/lfx-pcc/src/app/shared/services/meeting.service.ts b/apps/lfx-pcc/src/app/shared/services/meeting.service.ts
index eb9879d8..14eb1d4f 100644
--- a/apps/lfx-pcc/src/app/shared/services/meeting.service.ts
+++ b/apps/lfx-pcc/src/app/shared/services/meeting.service.ts
@@ -3,7 +3,16 @@
import { HttpClient, HttpParams } from '@angular/common/http';
import { inject, Injectable, signal, WritableSignal } from '@angular/core';
-import { CreateMeetingRequest, Meeting, MeetingAttachment, MeetingParticipant, UpdateMeetingRequest, UploadFileResponse } from '@lfx-pcc/shared/interfaces';
+import {
+ CreateMeetingRequest,
+ GenerateAgendaRequest,
+ GenerateAgendaResponse,
+ Meeting,
+ MeetingAttachment,
+ MeetingParticipant,
+ UpdateMeetingRequest,
+ UploadFileResponse,
+} from '@lfx-pcc/shared/interfaces';
import { catchError, defer, Observable, of, switchMap, take, tap, throwError } from 'rxjs';
@Injectable({
@@ -245,6 +254,16 @@ export class MeetingService {
);
}
+ public generateAgenda(request: GenerateAgendaRequest): Observable {
+ return this.http.post('/api/meetings/generate-agenda', request).pipe(
+ take(1),
+ catchError((error) => {
+ console.error('Failed to generate meeting agenda:', error);
+ throw error;
+ })
+ );
+ }
+
private readFileAsBase64(file: File): Promise {
return new Promise((resolve, reject) => {
const reader = new FileReader();
diff --git a/apps/lfx-pcc/src/app/shared/services/project.service.ts b/apps/lfx-pcc/src/app/shared/services/project.service.ts
index 070460ac..c3c6f103 100644
--- a/apps/lfx-pcc/src/app/shared/services/project.service.ts
+++ b/apps/lfx-pcc/src/app/shared/services/project.service.ts
@@ -17,8 +17,7 @@ export class ProjectService {
public getProjects(params?: HttpParams): Observable {
return this.http.get('/api/projects', { params }).pipe(
- catchError((error) => {
- console.error('Failed to load projects:', error);
+ catchError(() => {
return of([]);
})
);
@@ -26,8 +25,7 @@ export class ProjectService {
public getProject(slug: string): Observable {
return this.http.get(`/api/projects/${slug}`).pipe(
- catchError((error) => {
- console.error(`Failed to load project ${slug}:`, error);
+ catchError(() => {
return of(null);
}),
tap((project) => {
diff --git a/apps/lfx-pcc/src/index.html b/apps/lfx-pcc/src/index.html
index d1915d4c..ba247772 100644
--- a/apps/lfx-pcc/src/index.html
+++ b/apps/lfx-pcc/src/index.html
@@ -10,6 +10,16 @@
+
diff --git a/apps/lfx-pcc/src/server/routes/meetings.ts b/apps/lfx-pcc/src/server/routes/meetings.ts
index 887a9c8f..83c32c67 100644
--- a/apps/lfx-pcc/src/server/routes/meetings.ts
+++ b/apps/lfx-pcc/src/server/routes/meetings.ts
@@ -4,11 +4,13 @@
import { ALLOWED_FILE_TYPES, MAX_FILE_SIZE_BYTES, sanitizeFilename } from '@lfx-pcc/shared';
import { NextFunction, Request, Response, Router } from 'express';
+import { AiService } from '../services/ai.service';
import { SupabaseService } from '../services/supabase.service';
const router = Router();
const supabaseService = new SupabaseService();
+const aiService = new AiService();
router.get('/', async (req: Request, res: Response, next: NextFunction) => {
const startTime = Date.now();
@@ -762,4 +764,62 @@ router.get('/:id/attachments', async (req: Request, res: Response, next: NextFun
}
});
+// AI agenda generation endpoint
+router.post('/generate-agenda', async (req: Request, res: Response, next: NextFunction) => {
+ const startTime = Date.now();
+
+ req.log.info(
+ {
+ operation: 'generate_agenda',
+ meeting_type: req.body['meetingType'],
+ has_context: !!req.body['context'],
+ },
+ 'Starting AI agenda generation request'
+ );
+
+ try {
+ const { meetingType, title, projectName, context } = req.body;
+
+ // Validate required fields
+ if (!meetingType || !title || !projectName) {
+ return res.status(400).json({
+ error: 'Missing required fields: meetingType, title, and projectName are required',
+ });
+ }
+
+ const response = await aiService.generateMeetingAgenda({
+ meetingType,
+ title,
+ projectName,
+ context,
+ });
+
+ const duration = Date.now() - startTime;
+
+ req.log.info(
+ {
+ operation: 'generate_agenda',
+ duration,
+ estimated_duration: response.estimatedDuration,
+ status_code: 200,
+ },
+ 'Successfully generated meeting agenda'
+ );
+
+ return res.json(response);
+ } catch (error) {
+ const duration = Date.now() - startTime;
+ req.log.error(
+ {
+ error: error instanceof Error ? error.message : error,
+ operation: 'generate_agenda',
+ duration,
+ meeting_type: req.body['meetingType'],
+ },
+ 'Failed to generate meeting agenda'
+ );
+ return next(error);
+ }
+});
+
export default router;
diff --git a/apps/lfx-pcc/src/server/services/ai.service.ts b/apps/lfx-pcc/src/server/services/ai.service.ts
new file mode 100644
index 00000000..1b7f4968
--- /dev/null
+++ b/apps/lfx-pcc/src/server/services/ai.service.ts
@@ -0,0 +1,191 @@
+// Copyright The Linux Foundation and each contributor to LFX.
+// SPDX-License-Identifier: MIT
+
+import { AI_AGENDA_SYSTEM_PROMPT, AI_MODEL, AI_REQUEST_CONFIG, DURATION_ESTIMATION } from '@lfx-pcc/shared/constants';
+import { MeetingType } from '@lfx-pcc/shared/enums';
+import { GenerateAgendaRequest, GenerateAgendaResponse, OpenAIChatRequest, OpenAIChatResponse } from '@lfx-pcc/shared/interfaces';
+
+import { serverLogger } from '../server';
+
+export class AiService {
+ private readonly aiProxyUrl: string;
+ private readonly model = AI_MODEL;
+ private readonly aiKey = process.env['AI_API_KEY'] || 'sk-proj-1234567890';
+
+ public constructor() {
+ this.aiProxyUrl = process.env['AI_PROXY_URL'] || 'https://api.openai.com/v1/chat/completions';
+ if (!this.aiProxyUrl) {
+ throw new Error('AI_PROXY_URL environment variable is required');
+ }
+
+ if (!this.aiKey) {
+ throw new Error('AI_API_KEY environment variable is required');
+ }
+ }
+
+ public async generateMeetingAgenda(request: GenerateAgendaRequest): Promise {
+ try {
+ serverLogger.info('Generating meeting agenda', {
+ meetingType: request.meetingType,
+ title: request.title,
+ hasContext: !!request.context,
+ projectName: request.projectName,
+ });
+
+ const prompt = this.buildPrompt(request);
+ const chatRequest: OpenAIChatRequest = {
+ model: this.model,
+ messages: [
+ {
+ role: 'system',
+ content: AI_AGENDA_SYSTEM_PROMPT,
+ },
+ {
+ role: 'user',
+ content: prompt,
+ },
+ ],
+ max_tokens: AI_REQUEST_CONFIG.MAX_TOKENS,
+ temperature: AI_REQUEST_CONFIG.TEMPERATURE,
+ response_format: {
+ type: 'json_schema',
+ json_schema: {
+ name: 'meeting_agenda',
+ description: 'Generated meeting agenda with estimated duration',
+ schema: {
+ type: 'object',
+ properties: {
+ agenda: {
+ type: 'string',
+ description: 'Well-structured meeting agenda with time allocations and clear objectives',
+ },
+ duration: {
+ type: 'number',
+ description: 'Total estimated meeting duration in minutes',
+ },
+ },
+ required: ['agenda', 'duration'],
+ additionalProperties: false,
+ },
+ },
+ strict: true,
+ },
+ };
+
+ const response = await this.makeAiRequest(chatRequest);
+ const result = this.extractAgendaAndDuration(response);
+
+ serverLogger.info('Successfully generated meeting agenda', {
+ estimatedDuration: result.estimatedDuration,
+ });
+
+ return result;
+ } catch (error) {
+ serverLogger.error('Failed to generate meeting agenda', { error });
+ throw new Error('Failed to generate meeting agenda');
+ }
+ }
+
+ private buildPrompt(request: GenerateAgendaRequest): string {
+ let prompt = `Generate a meeting agenda for a ${this.getMeetingTypeDescription(request.meetingType)} meeting`;
+ prompt += ` titled "${request.title}" for the ${request.projectName} project.`;
+
+ if (request.context) {
+ prompt += ` Additional context: ${request.context}`;
+ }
+
+ prompt += '\n\nPlease create a professional, well-structured agenda that includes appropriate time allocations and clear objectives for each item.';
+
+ return prompt;
+ }
+
+ private getMeetingTypeDescription(meetingType: MeetingType): string {
+ switch (meetingType) {
+ case MeetingType.BOARD:
+ return 'board governance';
+ case MeetingType.MAINTAINERS:
+ return 'maintainers/technical steering committee';
+ case MeetingType.MARKETING:
+ return 'marketing and community outreach';
+ case MeetingType.TECHNICAL:
+ return 'technical working group';
+ case MeetingType.LEGAL:
+ return 'legal and compliance';
+ case MeetingType.OTHER:
+ return 'project team';
+ case MeetingType.NONE:
+ return 'general project';
+ default:
+ return 'project team';
+ }
+ }
+
+ private async makeAiRequest(request: OpenAIChatRequest): Promise {
+ const response = await fetch(this.aiProxyUrl, {
+ method: 'POST',
+ headers: {
+ ['Content-Type']: 'application/json',
+ ['Authorization']: `Bearer ${this.aiKey}`,
+ },
+ body: JSON.stringify(request),
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ throw new Error(`AI request failed: ${response.status} ${response.statusText} - ${errorText}`);
+ }
+
+ return response.json();
+ }
+
+ private extractAgendaAndDuration(response: OpenAIChatResponse): GenerateAgendaResponse {
+ if (!response.choices || response.choices.length === 0) {
+ throw new Error('No agenda generated');
+ }
+
+ const content = response.choices[0].message.content;
+
+ if (!content || content.trim().length === 0) {
+ throw new Error('Empty agenda generated');
+ }
+
+ try {
+ // Parse the JSON response
+ const parsed = JSON.parse(content.trim());
+
+ if (!parsed.agenda || typeof parsed.agenda !== 'string') {
+ throw new Error('Invalid agenda format in response');
+ }
+
+ if (!parsed.duration || typeof parsed.duration !== 'number') {
+ throw new Error('Invalid duration format in response');
+ }
+
+ // Cap duration between minimum and maximum limits
+ const cappedDuration = Math.max(DURATION_ESTIMATION.MINIMUM_DURATION, Math.min(parsed.duration, DURATION_ESTIMATION.MAXIMUM_DURATION));
+
+ return {
+ agenda: parsed.agenda.trim(),
+ estimatedDuration: cappedDuration,
+ };
+ } catch (parseError) {
+ serverLogger.warn('Failed to parse JSON response, falling back to text extraction', {
+ content: content.substring(0, 100),
+ error: parseError,
+ });
+
+ // Fallback to treating the entire content as agenda with heuristic duration
+ const lines = content.split('\n').filter((line) => line.trim().length > 0);
+ const estimatedItems = lines.filter((line) => line.match(/^[#\-*\d]/)).length;
+ const fallbackDuration = DURATION_ESTIMATION.BASE_DURATION + estimatedItems * DURATION_ESTIMATION.TIME_PER_ITEM;
+
+ // Cap fallback duration between minimum and maximum limits
+ const cappedFallbackDuration = Math.max(DURATION_ESTIMATION.MINIMUM_DURATION, Math.min(fallbackDuration, DURATION_ESTIMATION.MAXIMUM_DURATION));
+
+ return {
+ agenda: content.trim(),
+ estimatedDuration: cappedFallbackDuration,
+ };
+ }
+ }
+}
diff --git a/docs/architecture/backend/README.md b/docs/architecture/backend/README.md
index a600e5a9..bcfb1bbc 100644
--- a/docs/architecture/backend/README.md
+++ b/docs/architecture/backend/README.md
@@ -41,6 +41,20 @@ Request → Controller → Service → Microservice/Data Layer
- **CRUD Operations**: Create, Read, Update, Delete with ETag concurrency control
- **Query Service Integration**: Integration with LFX Query Service microservice
+#### AI Integration Service
+
+- **AI Service**: Claude Sonnet integration for meeting agenda generation
+- **LiteLLM Proxy**: OpenAI-compatible API proxy for AI model access
+- **JSON Schema Validation**: Strict response validation with fallback parsing
+- **Meeting API Integration**: Protected endpoints for AI-powered features
+
+#### NATS Messaging Service
+
+- **NATS Service**: High-performance inter-service messaging integration
+- **Project Slug Resolution**: Real-time project lookup via request-reply pattern
+- **Lazy Connection Management**: On-demand connection with automatic reconnection
+- **Kubernetes Service Discovery**: Native cluster DNS integration for NATS access
+
#### Authentication & Session Management
- **Auth0 Integration**: OpenID Connect with session-based authentication
@@ -61,6 +75,14 @@ Understand Auth0 integration, JWT handling, and user session management.
Explore Winston logging configuration, structured logging, and monitoring strategies.
+### [AI Service](./ai-service.md)
+
+Learn about AI integration, Claude Sonnet model configuration, and meeting agenda generation.
+
+### [NATS Integration](./nats-integration.md)
+
+Understand NATS messaging integration, project slug resolution, and inter-service communication.
+
### [Deployment](../../deployment.md)
Discover PM2 configuration, production deployment, and server management.
@@ -81,6 +103,7 @@ Discover PM2 configuration, production deployment, and server management.
- **Structured Logging**: Pino with request correlation, timing, and sensitive data redaction
- **Process Management**: PM2 for production deployment with health monitoring
- **Health Monitoring**: Built-in health check endpoints with detailed system status
+- **AI Integration**: Claude Sonnet model integration via LiteLLM proxy for intelligent features
### Development & Quality
@@ -221,7 +244,11 @@ apps/lfx-pcc/src/server/
│ ├── committee.service.ts
│ ├── etag.service.ts
│ ├── api-client.service.ts
-│ └── microservice-proxy.service.ts
+│ ├── microservice-proxy.service.ts
+│ ├── ai.service.ts
+│ ├── nats.service.ts
+│ ├── project.service.ts
+│ └── supabase.service.ts
├── helpers/ # Utility classes
│ ├── logger.ts # Standardized logging
│ ├── responder.ts # Response formatting
diff --git a/docs/architecture/backend/ai-service.md b/docs/architecture/backend/ai-service.md
new file mode 100644
index 00000000..291acdf1
--- /dev/null
+++ b/docs/architecture/backend/ai-service.md
@@ -0,0 +1,340 @@
+# AI Service Integration
+
+## 🤖 Overview
+
+The LFX PCC AI Service provides intelligent meeting agenda generation using **Claude Sonnet 4** through a **LiteLLM proxy**. The service integrates with the meeting creation workflow to automatically generate professional, structured meeting agendas based on meeting type, context, and project information.
+
+## 🏗 Architecture
+
+### Service Architecture
+
+```text
+Frontend Request → Meeting API → AI Service → LiteLLM Proxy → Claude Sonnet 4
+ ↓ ↓ ↓ ↓
+ Angular Express.js Business OpenAI-Compatible
+ Service Controller Logic Proxy
+```
+
+### Core Components
+
+- **AI Service** (`/server/services/ai.service.ts`): Core business logic for AI integration
+- **Meeting API** (`/server/routes/meetings.ts`): HTTP endpoints for AI-powered features
+- **LiteLLM Proxy**: OpenAI-compatible proxy for Claude Sonnet model access
+- **Shared Interfaces** (`@lfx-pcc/shared`): Type-safe request/response contracts
+
+## 🔧 Implementation Details
+
+### AI Service Configuration
+
+```typescript
+export class AiService {
+ private readonly aiProxyUrl: string;
+ private readonly model = AI_MODEL; // 'us.anthropic.claude-sonnet-4-20250514-v1:0'
+ private readonly aiKey = process.env['AI_API_KEY'] || '';
+
+ public constructor() {
+ this.aiProxyUrl = process.env['AI_PROXY_URL'] || '';
+ if (!this.aiProxyUrl || !this.aiKey) {
+ throw new Error('AI configuration environment variables are required');
+ }
+ }
+}
+```
+
+### Request/Response Schema
+
+#### Generate Agenda Request
+
+```typescript
+export interface GenerateAgendaRequest {
+ meetingType: MeetingType; // Meeting type enum (BOARD, TECHNICAL, etc.)
+ title: string; // Meeting title/topic
+ projectName: string; // Project name for context
+ context?: string; // Additional context from user
+}
+```
+
+#### Generate Agenda Response
+
+```typescript
+export interface GenerateAgendaResponse {
+ agenda: string; // Generated meeting agenda content
+ estimatedDuration: number; // Estimated meeting duration in minutes
+}
+```
+
+### JSON Schema Validation
+
+The service uses strict JSON schema validation to ensure reliable AI responses:
+
+```typescript
+response_format: {
+ type: 'json_schema',
+ json_schema: {
+ name: 'meeting_agenda',
+ description: 'Generated meeting agenda with estimated duration',
+ schema: {
+ type: 'object',
+ properties: {
+ agenda: {
+ type: 'string',
+ description: 'Well-structured meeting agenda with time allocations'
+ },
+ duration: {
+ type: 'number',
+ description: 'Total estimated meeting duration in minutes'
+ }
+ },
+ required: ['agenda', 'duration'],
+ additionalProperties: false
+ }
+ },
+ strict: true
+}
+```
+
+## 🚀 API Endpoints
+
+### Generate Meeting Agenda
+
+**Endpoint**: `POST /api/meetings/generate-agenda`
+
+**Authentication**: Required (Bearer token)
+
+**Request Body**:
+
+```json
+{
+ "meetingType": "TECHNICAL",
+ "title": "Q1 Architecture Review",
+ "projectName": "LFX Platform",
+ "context": "Review microservices architecture and discuss scaling plans"
+}
+```
+
+**Response**:
+
+```json
+{
+ "agenda": "**Meeting Objective**: Q1 Architecture Review\n\n**Agenda Items**:\n1. **System Overview** (10 min)...",
+ "estimatedDuration": 60
+}
+```
+
+**Error Responses**:
+
+- `400 Bad Request`: Missing required fields
+- `401 Unauthorized`: Invalid or missing authentication
+- `500 Internal Server Error`: AI service failure
+
+## 🔐 Security & Authentication
+
+### API Protection
+
+```typescript
+// Bearer token middleware applied to all API routes
+app.use('/api', extractBearerToken);
+
+// Protected meeting agenda endpoint
+router.post('/generate-agenda', async (req: Request, res: Response, next: NextFunction) => {
+ // Validates authentication before processing
+});
+```
+
+### Data Sanitization
+
+- **Request Logging**: Sensitive data automatically redacted from logs
+- **Input Validation**: All user inputs validated before AI processing
+- **Response Filtering**: AI responses validated against strict schema
+
+## 🛠 Configuration
+
+### Environment Variables
+
+```bash
+# AI Service Configuration
+AI_PROXY_URL={{https://lite-llm-url}}/chat/completions
+AI_API_KEY=your-ai-api-key
+```
+
+### Model Configuration
+
+```typescript
+// AI Constants (/packages/shared/src/constants/ai.constants.ts)
+export const AI_MODEL = 'us.anthropic.claude-sonnet-4-20250514-v1:0';
+
+export const AI_REQUEST_CONFIG = {
+ MAX_TOKENS: 4000,
+ TEMPERATURE: 0.3,
+};
+
+export const DURATION_ESTIMATION = {
+ BASE_DURATION: 30, // Base meeting duration in minutes
+ TIME_PER_ITEM: 5, // Additional time per agenda item
+ MINIMUM_DURATION: 15, // Minimum meeting duration
+};
+```
+
+### System Prompt
+
+```typescript
+export const AI_AGENDA_SYSTEM_PROMPT = `You are an expert meeting facilitator for open source projects.
+Generate professional, well-structured meeting agendas that include:
+
+1. Clear objectives and expected outcomes
+2. Time allocations for each agenda item
+3. Appropriate agenda items based on meeting type
+4. Consideration for open source project governance
+
+You must respond with a valid JSON object containing:
+- agenda: A detailed meeting agenda with markdown formatting
+- duration: Total estimated duration in minutes (15-240 range)
+
+Focus on transparency, collaboration, and effective time management.`;
+```
+
+## 🔄 Integration Workflow
+
+### Frontend Integration
+
+```typescript
+// Meeting Form Component
+public async generateAiAgenda(): Promise {
+ const request: GenerateAgendaRequest = {
+ meetingType: this.form().get('meeting_type')?.value,
+ title: this.form().get('topic')?.value,
+ projectName: this.projectService.project()?.name,
+ context: this.form().get('aiPrompt')?.value
+ };
+
+ this.meetingService.generateAgenda(request)
+ .subscribe(response => {
+ // Set generated agenda and duration
+ this.form().get('agenda')?.setValue(response.agenda);
+ this.setAiEstimatedDuration(response.estimatedDuration);
+ });
+}
+```
+
+### Backend Processing
+
+```typescript
+// AI Service Implementation
+public async generateMeetingAgenda(request: GenerateAgendaRequest): Promise {
+ const prompt = this.buildPrompt(request);
+ const chatRequest: OpenAIChatRequest = {
+ model: this.model,
+ messages: [
+ { role: 'system', content: AI_AGENDA_SYSTEM_PROMPT },
+ { role: 'user', content: prompt }
+ ],
+ response_format: { /* JSON schema */ },
+ max_tokens: AI_REQUEST_CONFIG.MAX_TOKENS,
+ temperature: AI_REQUEST_CONFIG.TEMPERATURE
+ };
+
+ const response = await this.makeAiRequest(chatRequest);
+ return this.extractAgendaAndDuration(response);
+}
+```
+
+## 🔍 Error Handling & Fallbacks
+
+### Response Parsing Strategy
+
+1. **Primary**: JSON schema with strict validation
+2. **Fallback**: Parse JSON manually if schema fails
+3. **Emergency**: Extract plain text with heuristic duration estimation
+
+```typescript
+private extractAgendaAndDuration(response: OpenAIChatResponse): GenerateAgendaResponse {
+ try {
+ // Primary: Parse strict JSON schema response
+ const parsed = JSON.parse(content.trim());
+ return {
+ agenda: parsed.agenda.trim(),
+ estimatedDuration: parsed.duration
+ };
+ } catch (parseError) {
+ // Fallback: Extract text with estimated duration
+ const lines = content.split('\n').filter(line => line.trim().length > 0);
+ const estimatedItems = lines.filter(line => line.match(/^[#\-*\d]/)).length;
+ const fallbackDuration = DURATION_ESTIMATION.BASE_DURATION +
+ estimatedItems * DURATION_ESTIMATION.TIME_PER_ITEM;
+
+ return {
+ agenda: content.trim(),
+ estimatedDuration: Math.max(DURATION_ESTIMATION.MINIMUM_DURATION, fallbackDuration)
+ };
+ }
+}
+```
+
+### Logging & Monitoring
+
+```typescript
+// Request logging with context
+serverLogger.info('Generating meeting agenda', {
+ meetingType: request.meetingType,
+ title: request.title,
+ hasContext: !!request.context,
+ projectName: request.projectName,
+});
+
+// Success logging with metrics
+serverLogger.info('Successfully generated meeting agenda', {
+ estimatedDuration: result.estimatedDuration,
+});
+
+// Error logging with details
+serverLogger.error('Failed to generate meeting agenda', { error });
+```
+
+## 🎯 Best Practices
+
+### Development Guidelines
+
+1. **Input Validation**: Always validate requests before AI processing
+2. **Error Handling**: Implement comprehensive error handling with fallbacks
+3. **Logging**: Log all AI operations with appropriate detail levels
+4. **Rate Limiting**: Consider implementing rate limiting for AI endpoints
+5. **Caching**: Cache responses for identical requests to reduce API costs
+
+### Security Considerations
+
+1. **Authentication**: All AI endpoints require valid authentication
+2. **Input Sanitization**: Sanitize user inputs to prevent prompt injection
+3. **Response Validation**: Validate AI responses against expected schemas
+4. **API Key Management**: Secure storage and rotation of AI API keys
+5. **Audit Logging**: Log all AI requests for audit and debugging purposes
+
+## 📊 Performance & Monitoring
+
+### Key Metrics
+
+- **Response Time**: AI request/response latency
+- **Success Rate**: Percentage of successful agenda generations
+- **Error Rate**: Rate of AI service failures and fallbacks
+- **Token Usage**: API token consumption for cost monitoring
+
+### Health Monitoring
+
+```typescript
+// Health check integration
+app.get('/api/health', (req, res) => {
+ const healthStatus = {
+ ai_service: {
+ configured: !!process.env['AI_PROXY_URL'] && !!process.env['AI_API_KEY'],
+ model: AI_MODEL,
+ },
+ };
+ res.json(healthStatus);
+});
+```
+
+## 🔗 Related Documentation
+
+- [Backend Architecture Overview](./README.md)
+- [Meeting API Routes](../../CLAUDE.md#api-routes)
+- [Shared Interfaces](../shared/package-architecture.md)
+- [Environment Configuration](../../deployment.md#environment-variables)
diff --git a/docs/architecture/backend/nats-integration.md b/docs/architecture/backend/nats-integration.md
new file mode 100644
index 00000000..a80597b4
--- /dev/null
+++ b/docs/architecture/backend/nats-integration.md
@@ -0,0 +1,404 @@
+# NATS Integration
+
+## 🚀 Overview
+
+The LFX PCC application integrates with **NATS** (Neural Autonomic Transport System) for high-performance inter-service messaging within the LFX microservices ecosystem. NATS provides lightweight, publish-subscribe, and request-reply communication patterns for distributed systems.
+
+## 🏗 Architecture
+
+### NATS Integration Pattern
+
+```text
+LFX PCC ←→ NATS Server ←→ LFX Microservices
+ ↓ ↓ ↓
+ Client Message Project
+ Requests Broker Services
+```
+
+### Core Components
+
+- **NATS Service** (`/server/services/nats.service.ts`): Core NATS client implementation
+- **Project Service Integration**: Uses NATS for project slug resolution
+- **Lazy Connection Management**: On-demand connection with automatic reconnection
+- **Request-Reply Pattern**: Synchronous communication with timeout handling
+
+## 🔧 Implementation Details
+
+### NATS Service Configuration
+
+```typescript
+export class NatsService {
+ private connection: NatsConnection | null = null;
+ private connectionPromise: Promise | null = null;
+ private codec = StringCodec();
+
+ public constructor() {
+ // Lazy initialization - no immediate connection
+ }
+}
+```
+
+### Connection Management
+
+#### Lazy Connection Strategy
+
+```typescript
+private async ensureConnection(): Promise {
+ // Return existing connection if valid
+ if (this.connection && !this.connection.isClosed()) {
+ return this.connection;
+ }
+
+ // If already connecting, wait for that connection
+ if (this.connectionPromise) {
+ return this.connectionPromise;
+ }
+
+ // Create new connection with thread safety
+ this.connectionPromise = this.createConnection();
+
+ try {
+ this.connection = await this.connectionPromise;
+ return this.connection;
+ } finally {
+ this.connectionPromise = null;
+ }
+}
+```
+
+#### Connection Configuration
+
+```typescript
+private async createConnection(): Promise {
+ const natsUrl = process.env['NATS_URL'] || NATS_CONFIG.DEFAULT_SERVER_URL;
+
+ const connection = await connect({
+ servers: [natsUrl],
+ timeout: NATS_CONFIG.CONNECTION_TIMEOUT, // 5000ms
+ });
+
+ return connection;
+}
+```
+
+## 📡 Message Subjects and Patterns
+
+### Defined Subjects
+
+```typescript
+export enum NatsSubjects {
+ PROJECT_SLUG_TO_UID = 'lfx.projects-api.slug_to_uid',
+}
+```
+
+### Request-Reply Pattern
+
+```typescript
+public async getProjectIdBySlug(slug: string): Promise {
+ const connection = await this.ensureConnection();
+
+ const response = await connection.request(
+ NatsSubjects.PROJECT_SLUG_TO_UID,
+ this.codec.encode(slug),
+ { timeout: NATS_CONFIG.REQUEST_TIMEOUT } // 5000ms
+ );
+
+ const projectId = this.codec.decode(response.data);
+
+ return {
+ projectId: projectId.trim(),
+ slug,
+ exists: projectId.trim() !== ''
+ };
+}
+```
+
+## 🔗 Service Integration
+
+### Project Service Integration
+
+```typescript
+export class ProjectService {
+ private natsService: NatsService;
+
+ public constructor() {
+ this.natsService = new NatsService();
+ }
+
+ public async getProjectBySlug(req: Request, slug: string): Promise {
+ // Use NATS to resolve project slug to ID
+ const { projectId, exists } = await this.natsService.getProjectIdBySlug(slug);
+
+ if (!exists) {
+ throw createApiError({
+ message: 'Project not found',
+ status: 404,
+ code: 'PROJECT_NOT_FOUND',
+ });
+ }
+
+ // Use resolved ID to fetch project details
+ return this.getProjectById(req, projectId);
+ }
+}
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+```bash
+# NATS Configuration
+# Internal k8s service DNS for NATS cluster
+NATS_URL=nats://lfx-platform-nats.lfx.svc.cluster.local:4222
+```
+
+### NATS Configuration Constants
+
+```typescript
+export const NATS_CONFIG = {
+ /**
+ * Default NATS server URL for Kubernetes cluster
+ */
+ DEFAULT_SERVER_URL: 'nats://lfx-platform-nats.lfx.svc.cluster.local:4222',
+
+ /**
+ * Connection timeout in milliseconds
+ */
+ CONNECTION_TIMEOUT: 5000,
+
+ /**
+ * Request timeout in milliseconds
+ */
+ REQUEST_TIMEOUT: 5000,
+} as const;
+```
+
+## 🔐 Security and Error Handling
+
+### Connection Security
+
+- **Kubernetes Service DNS**: Uses internal cluster DNS for secure communication
+- **Network Policies**: Security enforced at Kubernetes network level
+- **Connection Pooling**: Single connection per service instance
+- **Service Mesh Integration**: Compatible with Istio/Linkerd if deployed
+
+### Error Handling Strategy
+
+```typescript
+try {
+ const response = await connection.request(subject, data, { timeout });
+ return this.processResponse(response);
+} catch (error) {
+ // Handle timeout and no responder errors gracefully
+ if (error.message.includes('timeout') || error.message.includes('503')) {
+ serverLogger.info({ slug }, 'Project slug not found via NATS');
+ return { exists: false, projectId: '', slug };
+ }
+
+ // Re-throw connection and other critical errors
+ throw error;
+}
+```
+
+### Graceful Shutdown
+
+```typescript
+public async shutdown(): Promise {
+ if (this.connection && !this.connection.isClosed()) {
+ serverLogger.info('Shutting down NATS connection');
+
+ try {
+ await this.connection.drain(); // Graceful shutdown
+ serverLogger.info('NATS connection closed successfully');
+ } catch (error) {
+ serverLogger.error({ error }, 'Error during NATS shutdown');
+ }
+ }
+ this.connection = null;
+}
+```
+
+## 📊 Monitoring and Logging
+
+### Connection Monitoring
+
+```typescript
+public isConnected(): boolean {
+ return this.connection !== null && !this.connection.isClosed();
+}
+```
+
+### Request Logging
+
+```typescript
+// Success logging
+serverLogger.info({ slug, project_id: projectId }, 'Successfully resolved project slug to ID');
+
+// Error logging
+serverLogger.error({ error, slug }, 'Failed to resolve project slug via NATS');
+
+// Connection logging
+serverLogger.info({ url: natsUrl }, 'Connecting to NATS server on demand');
+```
+
+### Health Check Integration
+
+```typescript
+// Health endpoint includes NATS status
+app.get('/api/health', (req, res) => {
+ const healthStatus = {
+ nats: {
+ connected: natsService.isConnected(),
+ url: process.env['NATS_URL'] || NATS_CONFIG.DEFAULT_SERVER_URL,
+ },
+ };
+ res.json(healthStatus);
+});
+```
+
+## 🔧 Development and Troubleshooting
+
+### Local Development Setup
+
+Since NATS runs in the local Kubernetes cluster, the application connects directly using the Kubernetes service DNS:
+
+```bash
+# Environment configuration for local development
+NATS_URL=nats://lfx-platform-nats.lfx.svc.cluster.local:4222
+```
+
+### Kubernetes Service Discovery
+
+The application leverages Kubernetes service discovery:
+
+- **Service Name**: `lfx-platform-nats`
+- **Namespace**: `lfx`
+- **Port**: `4222`
+- **Full DNS**: `lfx-platform-nats.lfx.svc.cluster.local:4222`
+
+### Common Issues and Solutions
+
+#### 1. DNS Resolution Issues
+
+```text
+Error: getaddrinfo ENOTFOUND lfx-platform-nats.lfx.svc.cluster.local
+Cause: Kubernetes DNS not accessible or service not running
+Solution: Verify NATS service is deployed and accessible in cluster
+```
+
+#### 2. Connection Timeout
+
+```text
+Error: Failed to connect to NATS server
+Cause: NATS server not responding or network issues
+Solution: Check NATS pod status and network policies
+```
+
+#### 3. Request Timeout
+
+```text
+Error: Request timeout on NATS subject
+Cause: No service responding to the subject or high latency
+Solution: Verify target microservice deployment and health
+```
+
+### Debugging Commands
+
+```bash
+# Check NATS pod status
+kubectl get pods -n lfx -l app=nats
+
+# Check NATS service
+kubectl get svc -n lfx lfx-platform-nats
+
+# Check NATS logs
+kubectl logs -n lfx deployment/lfx-platform-nats
+
+# Test NATS connectivity from within cluster
+kubectl run nats-test --rm -i --tty --image=natsio/nats-box -- nats pub test "hello"
+```
+
+## 🎯 Best Practices
+
+### Performance Optimization
+
+1. **Lazy Connection**: Connect only when needed to reduce startup time
+2. **Connection Reuse**: Single connection per service instance
+3. **Request Timeouts**: Always use timeouts to prevent hanging requests
+4. **Graceful Shutdown**: Properly drain connections on service shutdown
+
+### Error Handling
+
+1. **Timeout Handling**: Treat timeouts as "not found" for optional data
+2. **Circuit Breaking**: Implement circuit breaker for degraded service scenarios
+3. **Fallback Strategies**: Provide alternative data sources when NATS is unavailable
+4. **Retry Logic**: Consider exponential backoff for transient failures
+
+### Code Quality
+
+1. **Type Safety**: Use TypeScript interfaces for message payloads
+2. **Subject Constants**: Define subjects as enums to prevent typos
+3. **Error Logging**: Log all NATS operations with appropriate context
+4. **Unit Testing**: Mock NATS connections for comprehensive testing
+
+## 📈 Performance Metrics
+
+### Key Metrics to Monitor
+
+- **Connection Status**: Track connection health and reconnections
+- **Request Latency**: Monitor request-reply response times
+- **Error Rate**: Track timeout and connection failures
+- **Message Volume**: Monitor message throughput and patterns
+
+### Request Performance Logging
+
+```typescript
+// Request timing and metrics
+const startTime = Date.now();
+try {
+ const response = await connection.request(subject, data, { timeout });
+ const duration = Date.now() - startTime;
+
+ serverLogger.info(
+ {
+ subject,
+ duration,
+ success: true,
+ slug,
+ },
+ 'NATS request completed successfully'
+ );
+
+ return response;
+} catch (error) {
+ const duration = Date.now() - startTime;
+
+ serverLogger.error(
+ {
+ subject,
+ duration,
+ success: false,
+ error: error.message,
+ slug,
+ },
+ 'NATS request failed'
+ );
+
+ throw error;
+}
+```
+
+## 🔗 Related Documentation
+
+- [Backend Architecture Overview](./README.md)
+- [Project Service Integration](../../CLAUDE.md#backend-stack)
+- [Environment Configuration](../../deployment.md#environment-variables)
+- [Microservice Proxy Service](./README.md#microservice-integration)
+
+## 📚 External Resources
+
+- [NATS.io Documentation](https://docs.nats.io/)
+- [NATS TypeScript Client](https://github.com/nats-io/nats.js)
+- [NATS Request-Reply Pattern](https://docs.nats.io/nats-concepts/reqreply)
+- [Kubernetes Service Discovery](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
diff --git a/docs/architecture/backend/ssr-server.md b/docs/architecture/backend/ssr-server.md
index b2875df3..828aa444 100644
--- a/docs/architecture/backend/ssr-server.md
+++ b/docs/architecture/backend/ssr-server.md
@@ -24,6 +24,7 @@ import { extractBearerToken } from './middleware/auth-token.middleware';
import { apiErrorHandler } from './middleware/error-handler.middleware';
import { tokenRefreshMiddleware } from './middleware/token-refresh.middleware';
import projectsRouter from './routes/projects';
+import meetingsRouter from './routes/meetings';
dotenv.config();
@@ -106,6 +107,7 @@ app.use('/api', extractBearerToken);
// Mount API routes before Angular SSR
app.use('/api/projects', projectsRouter);
+app.use('/api/meetings', meetingsRouter);
// Add API error handler middleware
app.use('/api/*', apiErrorHandler);
@@ -271,8 +273,11 @@ src/server/
│ ├── auth-token.middleware.ts # Bearer token extraction
│ ├── error-handler.middleware.ts # API error handling
│ └── token-refresh.middleware.ts # Auth0 token refresh
-└── routes/
- └── projects.ts # Project API routes
+├── routes/
+│ ├── projects.ts # Project API routes
+│ └── meetings.ts # Meeting API routes (including AI endpoints)
+└── services/
+ └── ai.service.ts # AI integration service
```
This Express.js configuration provides a robust foundation for serving Angular 19 SSR applications with proper security, performance, and development features.
diff --git a/docs/deployment.md b/docs/deployment.md
index 70a5cc62..85eb5c7f 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -189,24 +189,46 @@ The application uses GitHub Actions for automated deployment to AWS ECS:
```bash
# Application Configuration
NODE_ENV=production
-PORT=4200
-PM2=true
-PCC_BASE_URL=https://pcc.lfx.dev
-# Auth0 Authentication
-PCC_AUTH0_CLIENT_ID=production-client-id
-PCC_AUTH0_CLIENT_SECRET=production-client-secret
-PCC_AUTH0_ISSUER_BASE_URL=https://linuxfoundation.auth0.com
-PCC_AUTH0_AUDIENCE=https://api.lfx.dev
-PCC_AUTH0_SECRET=production-secret
+# Environment Configuration
+ENV=development
+PCC_BASE_URL=http://localhost:4200
+LOG_LEVEL=info
+
+# Auth0 Authentication Configuration
+# Get these values from your Auth0 dashboard
+PCC_AUTH0_CLIENT_ID=your-auth0-client-id
+PCC_AUTH0_CLIENT_SECRET=your-auth0-client-secret
+PCC_AUTH0_ISSUER_BASE_URL=https://auth.k8s.orb.local
+PCC_AUTH0_AUDIENCE=http://lfx-api.k8s.orb.local/
+PCC_AUTH0_SECRET=sufficiently-long-string
# Microservice Configuration
-QUERY_SERVICE_URL=https://api.lfx.dev/query/resources
-QUERY_SERVICE_TOKEN=production-jwt-token
+# URL and JWT token for the query service
+LFX_V2_SERVICE=http://lfx-api.k8s.orb.local
-# Database Configuration (Supabase)
+# Supabase Database Configuration
+# Get these from your Supabase project settings
SUPABASE_URL=https://your-project.supabase.co
-POSTGRES_API_KEY=production-supabase-key
+POSTGRES_API_KEY=your-supabase-anon-key
+SUPABASE_STORAGE_BUCKET=your-supabase-bucket-name
+
+# NATS Configuration
+# Internal k8s service DNS for NATS cluster
+NATS_URL=nats://lfx-platform-nats.lfx.svc.cluster.local:4222
+
+# AI Service Configuration
+# OpenAI-compatible proxy for meeting agenda generation
+AI_PROXY_URL=https://litellm.tools.lfx.dev/chat/completions
+AI_API_KEY=your-ai-api-key
+
+# E2E Test Configuration (Optional)
+# Test user credentials for automated testing
+TEST_USERNAME=your-test-username
+TEST_PASSWORD=your-test-password
+
+# LOCAL ONLY FOR AUTHELIA
+NODE_TLS_REJECT_UNAUTHORIZED=0
```
## 🔧 Production Setup Steps
diff --git a/packages/shared/src/constants/ai.constants.ts b/packages/shared/src/constants/ai.constants.ts
new file mode 100644
index 00000000..8aa48dfb
--- /dev/null
+++ b/packages/shared/src/constants/ai.constants.ts
@@ -0,0 +1,45 @@
+// Copyright The Linux Foundation and each contributor to LFX.
+// SPDX-License-Identifier: MIT
+
+/**
+ * System prompt for AI meeting agenda generation
+ */
+export const AI_AGENDA_SYSTEM_PROMPT = `You are an expert meeting facilitator and agenda creator for open source software projects and organizations. Your role is to generate well-structured, comprehensive meeting agendas that promote productive discussions and clear outcomes.
+
+Key principles:
+- Create agendas that are time-boxed and actionable
+- Include clear objectives for each agenda item
+- Structure items logically from administrative to strategic topics
+- Ensure adequate time for discussion and decision-making
+- Follow best practices for meeting facilitation
+
+You must respond with a valid JSON object in this exact format:
+{
+ "agenda": "string containing the agenda with clear section headers, time allocations, and action-oriented language",
+ "duration": "number representing the total estimated duration in minutes"
+}
+
+The agenda should be well-structured plain text with time allocations for each item. The duration should be the sum of all time allocations plus any buffer time needed. Do not include any text outside the JSON object.`;
+
+/**
+ * AI model configuration
+ */
+export const AI_MODEL = 'us.anthropic.claude-sonnet-4-20250514-v1:0';
+
+/**
+ * AI request configuration
+ */
+export const AI_REQUEST_CONFIG = {
+ MAX_TOKENS: 4000,
+ TEMPERATURE: 0.7,
+};
+
+/**
+ * Duration estimation configuration
+ */
+export const DURATION_ESTIMATION = {
+ BASE_DURATION: 15, // Opening/closing time in minutes
+ TIME_PER_ITEM: 10, // Average time per agenda item in minutes
+ MINIMUM_DURATION: 30, // Minimum meeting duration in minutes
+ MAXIMUM_DURATION: 240, // Maximum meeting duration in minutes (4 hours)
+};
diff --git a/packages/shared/src/constants/index.ts b/packages/shared/src/constants/index.ts
index 209359ac..4dc413cb 100644
--- a/packages/shared/src/constants/index.ts
+++ b/packages/shared/src/constants/index.ts
@@ -1,6 +1,7 @@
// Copyright The Linux Foundation and each contributor to LFX.
// SPDX-License-Identifier: MIT
+export * from './ai.constants';
export * from './api.constants';
export * from './colors.constants';
export * from './committees.constants';
diff --git a/packages/shared/src/interfaces/ai.interface.ts b/packages/shared/src/interfaces/ai.interface.ts
new file mode 100644
index 00000000..7da897e6
--- /dev/null
+++ b/packages/shared/src/interfaces/ai.interface.ts
@@ -0,0 +1,82 @@
+// Copyright The Linux Foundation and each contributor to LFX.
+// SPDX-License-Identifier: MIT
+
+import { MeetingType } from '../enums';
+
+/**
+ * Request interface for AI agenda generation
+ */
+export interface GenerateAgendaRequest {
+ /** Type of meeting for agenda generation */
+ meetingType: MeetingType;
+ /** Meeting title */
+ title: string;
+ /** Name of the project for contextualized agenda */
+ projectName: string;
+ /** Additional context or specific requirements */
+ context?: string;
+}
+
+/**
+ * Response interface for AI agenda generation
+ */
+export interface GenerateAgendaResponse {
+ /** Generated agenda content in markdown format */
+ agenda: string;
+ /** AI-estimated duration in minutes (30-240 range) */
+ estimatedDuration: number;
+}
+
+/**
+ * OpenAI chat message interface
+ */
+export interface OpenAIChatMessage {
+ /** Role of the message sender */
+ role: 'system' | 'user' | 'assistant';
+ /** Content of the message */
+ content: string;
+}
+
+/**
+ * OpenAI chat completion request interface
+ */
+export interface OpenAIChatRequest {
+ /** Model identifier */
+ model: string;
+ /** Array of chat messages */
+ messages: OpenAIChatMessage[];
+ /** Maximum tokens to generate */
+ max_tokens?: number;
+ /** Sampling temperature for response variability */
+ temperature?: number;
+ /** Response format specification */
+ response_format?: {
+ /** Type of response format */
+ type: 'text' | 'json_object' | 'json_schema';
+ /** JSON schema definition when type is json_schema */
+ json_schema?: {
+ /** Schema name */
+ name: string;
+ /** Schema description */
+ description?: string;
+ /** JSON schema definition */
+ schema: Record;
+ };
+ /** Strict mode for JSON schema validation */
+ strict?: boolean;
+ };
+}
+
+/**
+ * OpenAI chat completion response interface
+ */
+export interface OpenAIChatResponse {
+ /** Array of response choices */
+ choices: Array<{
+ /** Generated message */
+ message: {
+ /** Content of the generated message */
+ content: string;
+ };
+ }>;
+}
diff --git a/packages/shared/src/interfaces/index.ts b/packages/shared/src/interfaces/index.ts
index a947a95e..e12a3c92 100644
--- a/packages/shared/src/interfaces/index.ts
+++ b/packages/shared/src/interfaces/index.ts
@@ -42,3 +42,6 @@ export * from './dashboard.interface';
// NATS interfaces
export * from './nats.interface';
+
+// AI interfaces
+export * from './ai.interface';
diff --git a/packages/shared/src/utils/date-time.utils.ts b/packages/shared/src/utils/date-time.utils.ts
index eda0f00f..257f36b1 100644
--- a/packages/shared/src/utils/date-time.utils.ts
+++ b/packages/shared/src/utils/date-time.utils.ts
@@ -2,18 +2,19 @@
// SPDX-License-Identifier: MIT
import { fromZonedTime, toZonedTime } from 'date-fns-tz';
-import { RecurrenceType } from '../enums';
-import { MeetingRecurrence } from '../interfaces';
+
import {
- TIME_ROUNDING_MINUTES,
- WEEKDAY_CODES,
+ DAYS_IN_WEEK,
DEFAULT_REPEAT_INTERVAL,
MINUTES_IN_HOUR,
- DAYS_IN_WEEK,
MS_IN_DAY,
+ TIME_ROUNDING_MINUTES,
+ TimezoneOption,
TIMEZONES,
- type TimezoneOption,
+ WEEKDAY_CODES,
} from '../constants';
+import { RecurrenceType } from '../enums';
+import { MeetingRecurrence } from '../interfaces';
// ============================================================================
// Date Formatting and Parsing Utilities
@@ -100,12 +101,12 @@ export function combineDateTime(date: Date, time: string, timezone?: string): st
// ============================================================================
/**
- * Gets default start date and time (1 hour from now, rounded to next 15 minutes)
+ * Gets default start date and time (1 week from now, rounded to next 15 minutes)
*/
export function getDefaultStartDateTime(): { date: Date; time: string } {
const now = new Date();
// Add 1 hour to current time
- now.setHours(now.getHours() + 1);
+ now.setDate(now.getDate() + 7);
// Round up to next 15 minutes
const minutes = now.getMinutes();