feat: enhance DevlogService to manage notes, update API routes for notes retrieval and inclusion

Author: tikazyq

package.json

@@ -64,5 +64,6 @@
     "better-sqlite3": "^11.10.0",
     "dotenv": "16.5.0",
     "tsx": "^4.0.0"
-  }
+  },
+  "packageManager": "[email protected]+sha512.37ebf1a5c7a30d5fabe0c5df44ee8da4c965ca0c5af3dbab28c3a1681b70a256218d05c81c9c0dcf767ef6b8551eb5b960042b9ed4300c59242336377e01cfad"
 }

packages/core/src/services/devlog-service.ts

@@ -31,11 +31,13 @@ export class DevlogService {
   private static readonly TTL_MS = 5 * 60 * 1000; // 5 minutes TTL
   private database: DataSource;
   private devlogRepository: Repository<DevlogEntryEntity>;
+  private noteRepository: Repository<DevlogNoteEntity>;
 
   private constructor(private projectId?: number) {
     // Database initialization will happen in ensureInitialized()
     this.database = null as any; // Temporary placeholder
     this.devlogRepository = null as any; // Temporary placeholder
+    this.noteRepository = null as any; // Temporary placeholder
   }
 
   /**
@@ -47,6 +49,7 @@ export class DevlogService {
         console.log('[DevlogService] Getting initialized DataSource...');
         this.database = await getDataSource();
         this.devlogRepository = this.database.getRepository(DevlogEntryEntity);
+        this.noteRepository = this.database.getRepository(DevlogNoteEntity);
         console.log(
           '[DevlogService] DataSource ready with entities:',
           this.database.entityMetadatas.length,
@@ -79,7 +82,7 @@ export class DevlogService {
     return existingInstance.service;
   }
 
-  async get(id: DevlogId): Promise<DevlogEntry | null> {
+  async get(id: DevlogId, includeNotes = true): Promise<DevlogEntry | null> {
     await this.ensureInitialized();
 
     // Validate devlog ID
@@ -94,7 +97,51 @@ export class DevlogService {
       return null;
     }
 
-    return entity.toDevlogEntry();
+    const devlogEntry = entity.toDevlogEntry();
+
+    // Load notes if requested
+    if (includeNotes) {
+      devlogEntry.notes = await this.getNotes(id);
+    }
+
+    return devlogEntry;
+  }
+
+  /**
+   * Get notes for a specific devlog entry
+   */
+  async getNotes(
+    devlogId: DevlogId,
+    limit?: number,
+  ): Promise<import('../types/index.js').DevlogNote[]> {
+    await this.ensureInitialized();
+
+    // Validate devlog ID
+    const idValidation = DevlogValidator.validateDevlogId(devlogId);
+    if (!idValidation.success) {
+      throw new Error(`Invalid devlog ID: ${idValidation.errors.join(', ')}`);
+    }
+
+    const queryBuilder = this.noteRepository
+      .createQueryBuilder('note')
+      .where('note.devlogId = :devlogId', { devlogId: idValidation.data })
+      .orderBy('note.timestamp', 'DESC');
+
+    if (limit && limit > 0) {
+      queryBuilder.limit(limit);
+    }
+
+    const noteEntities = await queryBuilder.getMany();
+
+    return noteEntities.map((entity) => ({
+      id: entity.id,
+      timestamp: entity.timestamp.toISOString(),
+      category: entity.category,
+      content: entity.content,
+      files: entity.files || [],
+      codeChanges: entity.codeChanges,
+      metadata: entity.metadata,
+    }));
   }
 
   async save(entry: DevlogEntry): Promise<void> {
@@ -139,9 +186,55 @@ export class DevlogService {
       }
     }
 
-    // Convert to entity and save
-    const entity = DevlogEntryEntity.fromDevlogEntry(validatedEntry);
-    await this.devlogRepository.save(entity);
+    // Handle notes separately - save to DevlogNoteEntity table
+    const notesToSave = validatedEntry.notes || [];
+
+    // Convert to entity and save (without notes in JSON)
+    const entryWithoutNotes = { ...validatedEntry };
+    delete entryWithoutNotes.notes; // Remove notes from the main entity
+
+    const entity = DevlogEntryEntity.fromDevlogEntry(entryWithoutNotes);
+    const savedEntity = await this.devlogRepository.save(entity);
+
+    // Save notes to separate table if entry has an ID
+    if (savedEntity.id && notesToSave.length > 0) {
+      await this.saveNotes(savedEntity.id, notesToSave);
+    }
+  }
+
+  /**
+   * Save notes for a devlog entry to the notes table
+   */
+  private async saveNotes(
+    devlogId: number,
+    notes: import('../types/index.js').DevlogNote[],
+  ): Promise<void> {
+    // Get existing notes to determine which are new
+    const existingNotes = await this.noteRepository.find({
+      where: { devlogId },
+      select: ['id'],
+    });
+    const existingNoteIds = new Set(existingNotes.map((n) => n.id));
+
+    // Only save new notes (ones that don't exist in DB)
+    const newNotes = notes.filter((note) => !existingNoteIds.has(note.id));
+
+    if (newNotes.length > 0) {
+      const noteEntities = newNotes.map((note) => {
+        const entity = new DevlogNoteEntity();
+        entity.id = note.id;
+        entity.devlogId = devlogId;
+        entity.timestamp = new Date(note.timestamp);
+        entity.category = note.category;
+        entity.content = note.content;
+        entity.files = note.files || [];
+        entity.codeChanges = note.codeChanges;
+        entity.metadata = note.metadata;
+        return entity;
+      });
+
+      await this.noteRepository.save(noteEntities);
+    }
   }
 
   async delete(id: DevlogId): Promise<void> {

packages/web/app/api/projects/[id]/devlogs/[devlogId]/notes/route.ts

@@ -7,6 +7,63 @@ import type { NoteCategory } from '@codervisor/devlog-core';
 // Mark this route as dynamic to prevent static generation
 export const dynamic = 'force-dynamic';
 
+// GET /api/projects/[id]/devlogs/[devlogId]/notes - List notes for a devlog entry
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string; devlogId: string } },
+) {
+  try {
+    // Parse and validate parameters
+    const paramResult = RouteParams.parseProjectAndDevlogId(params);
+    if (!paramResult.success) {
+      return paramResult.response;
+    }
+
+    const { projectId, devlogId } = paramResult.data;
+
+    // Parse query parameters
+    const { searchParams } = new URL(request.url);
+    const limit = searchParams.get('limit') ? parseInt(searchParams.get('limit')!) : undefined;
+    const category = searchParams.get('category');
+
+    // Validate limit if provided
+    if (limit !== undefined && (isNaN(limit) || limit < 1 || limit > 1000)) {
+      return ApiErrors.invalidRequest('Limit must be a number between 1 and 1000');
+    }
+
+    // Ensure project exists
+    const projectService = ProjectService.getInstance();
+    const project = await projectService.get(projectId);
+    if (!project) {
+      return ApiErrors.projectNotFound();
+    }
+
+    // Create project-aware devlog service
+    const devlogService = DevlogService.getInstance(projectId);
+
+    // Verify devlog exists
+    const devlogEntry = await devlogService.get(devlogId, false); // Don't load notes yet
+    if (!devlogEntry) {
+      return ApiErrors.devlogNotFound();
+    }
+
+    // Get notes for this devlog
+    const notes = await devlogService.getNotes(devlogId, limit);
+
+    // Filter by category if specified
+    const filteredNotes = category ? notes.filter((note) => note.category === category) : notes;
+
+    return NextResponse.json({
+      devlogId,
+      total: filteredNotes.length,
+      notes: filteredNotes,
+    });
+  } catch (error) {
+    console.error('Error listing devlog notes:', error);
+    return ApiErrors.internalError('Failed to list notes for devlog entry');
+  }
+}
+
 // Schema for adding notes
 const AddNoteBodySchema = z.object({
   note: z.string().min(1, 'Note is required'),

packages/web/app/api/projects/[id]/devlogs/[devlogId]/route.ts

@@ -19,19 +19,31 @@ export async function GET(
 
     const { projectId, devlogId } = paramResult.data;
 
+    // Parse query parameters for notes
+    const { searchParams } = new URL(request.url);
+    const includeNotes = searchParams.get('includeNotes') !== 'false'; // Include by default
+    const notesLimit = searchParams.get('notesLimit')
+      ? parseInt(searchParams.get('notesLimit')!)
+      : undefined;
+
     const projectService = ProjectService.getInstance();
     const project = await projectService.get(projectId);
     if (!project) {
       return ApiErrors.projectNotFound();
     }
 
     const devlogService = DevlogService.getInstance(projectId);
-    const entry = await devlogService.get(devlogId);
+    const entry = await devlogService.get(devlogId, includeNotes);
 
     if (!entry) {
       return ApiErrors.devlogNotFound();
     }
 
+    // If notesLimit is specified and we have notes, limit them to the most recent
+    if (entry.notes && notesLimit && entry.notes.length > notesLimit) {
+      entry.notes = entry.notes.slice(0, notesLimit);
+    }
+
     return NextResponse.json(entry);
   } catch (error) {
     console.error('Error fetching devlog:', error);