devchain-cli 0.6.0 → 0.7.0

package/dist/server/modules/storage/local/local-storage.service.js

@@ -696,7 +696,13 @@ let LocalStorageService = class LocalStorageService {
             .where(eq(epics.projectId, projectId))
             .limit(limit)
             .offset(offset);
-        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        const epicIds = items.map((item) => item.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const itemsWithTags = items.map((item) => ({
+            ...item,
+            data: item.data,
+            tags: tagsMap.get(item.id) ?? [],
+        }));
         return {
             items: itemsWithTags,
             total: items.length,
@@ -715,7 +721,13 @@ let LocalStorageService = class LocalStorageService {
             .where(eq(epics.statusId, statusId))
             .limit(limit)
             .offset(offset);
-        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        const epicIds = items.map((item) => item.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const itemsWithTags = items.map((item) => ({
+            ...item,
+            data: item.data,
+            tags: tagsMap.get(item.id) ?? [],
+        }));
         return {
             items: itemsWithTags,
             total: items.length,
@@ -733,7 +745,14 @@ let LocalStorageService = class LocalStorageService {
             const search = options.q.trim().toLowerCase();
             if (search.length) {
                 const pattern = `%${search}%`;
-                conditions.push(sql `(lower(${epics.title}) LIKE ${pattern} OR lower(ifnull(${epics.description}, '')) LIKE ${pattern})`);
+                const isUuidPrefix = search.length >= 8 && /^[a-f0-9-]+$/.test(search);
+                if (isUuidPrefix) {
+                    const idPrefixPattern = `${search}%`;
+                    conditions.push(sql `(lower(${epics.title}) LIKE ${pattern} OR lower(ifnull(${epics.description}, '')) LIKE ${pattern} OR ${epics.id} LIKE ${idPrefixPattern})`);
+                }
+                else {
+                    conditions.push(sql `(lower(${epics.title}) LIKE ${pattern} OR lower(ifnull(${epics.description}, '')) LIKE ${pattern})`);
+                }
             }
         }
         if (options.statusId) {
@@ -764,14 +783,20 @@ let LocalStorageService = class LocalStorageService {
             .where(whereClause);
         const total = Number(totalResult[0]?.count ?? 0);
         const rows = await this.db
-            .select({ id: epics.id })
+            .select({ epic: epics })
             .from(epics)
             .innerJoin(statuses, eq(statuses.id, epics.statusId))
             .where(whereClause)
             .orderBy(desc(epics.updatedAt))
             .limit(limit)
             .offset(offset);
-        const items = await Promise.all(rows.map((row) => this.getEpic(row.id)));
+        const epicIds = rows.map((row) => row.epic.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const items = rows.map((row) => ({
+            ...row.epic,
+            data: row.epic.data,
+            tags: tagsMap.get(row.epic.id) ?? [],
+        }));
         return {
             items,
             total,
@@ -804,13 +829,19 @@ let LocalStorageService = class LocalStorageService {
             .where(whereClause);
         const total = Number(totalResult[0]?.count ?? 0);
         const rows = await this.db
-            .select({ id: epics.id })
+            .select()
             .from(epics)
             .where(whereClause)
             .orderBy(desc(epics.updatedAt))
             .limit(limit)
             .offset(offset);
-        const items = await Promise.all(rows.map((row) => this.getEpic(row.id)));
+        const epicIds = rows.map((row) => row.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const items = rows.map((row) => ({
+            ...row,
+            data: row.data,
+            tags: tagsMap.get(row.id) ?? [],
+        }));
         return {
             items,
             total,
@@ -2690,6 +2721,364 @@ let LocalStorageService = class LocalStorageService {
             updatedAt: now,
         };
     }
+    async createReview(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { reviews } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const review = {
+            id: randomUUID(),
+            projectId: data.projectId,
+            epicId: data.epicId,
+            title: data.title,
+            description: data.description,
+            status: data.status,
+            mode: data.mode,
+            baseRef: data.baseRef,
+            headRef: data.headRef,
+            baseSha: data.baseSha,
+            headSha: data.headSha,
+            createdBy: data.createdBy,
+            createdByAgentId: data.createdByAgentId,
+            version: 1,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(reviews).values({
+            id: review.id,
+            projectId: review.projectId,
+            epicId: review.epicId,
+            title: review.title,
+            description: review.description,
+            status: review.status,
+            mode: review.mode,
+            baseRef: review.baseRef,
+            headRef: review.headRef,
+            baseSha: review.baseSha,
+            headSha: review.headSha,
+            createdBy: review.createdBy,
+            createdByAgentId: review.createdByAgentId,
+            version: review.version,
+            createdAt: review.createdAt,
+            updatedAt: review.updatedAt,
+        });
+        logger.info({ reviewId: review.id, projectId: review.projectId }, 'Created review');
+        return review;
+    }
+    async getReview(id) {
+        const { reviews, reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, count } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db.select().from(reviews).where(eq(reviews.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Review', id);
+        }
+        const countResult = await this.db
+            .select({ count: count() })
+            .from(reviewComments)
+            .where(eq(reviewComments.reviewId, id));
+        return {
+            ...result[0],
+            commentCount: countResult[0]?.count ?? 0,
+        };
+    }
+    async updateReview(id, data, expectedVersion) {
+        const { reviews } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const current = await this.getReview(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('Review', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        const updateData = {};
+        if (data.title !== undefined)
+            updateData.title = data.title;
+        if (data.description !== undefined)
+            updateData.description = data.description;
+        if (data.status !== undefined)
+            updateData.status = data.status;
+        if (data.headSha !== undefined)
+            updateData.headSha = data.headSha;
+        await this.db
+            .update(reviews)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(reviews.id, id));
+        logger.info({ reviewId: id }, 'Updated review');
+        return this.getReview(id);
+    }
+    async deleteReview(id) {
+        const { reviews } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(reviews).where(eq(reviews.id, id));
+        logger.info({ reviewId: id }, 'Deleted review');
+    }
+    async listReviews(projectId, options = {}) {
+        const { reviews, reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, count, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const conditions = [eq(reviews.projectId, projectId)];
+        if (options.status) {
+            conditions.push(eq(reviews.status, options.status));
+        }
+        if (options.epicId) {
+            conditions.push(eq(reviews.epicId, options.epicId));
+        }
+        const rows = await this.db
+            .select()
+            .from(reviews)
+            .where(and(...conditions))
+            .orderBy(desc(reviews.createdAt))
+            .limit(limit)
+            .offset(offset);
+        const reviewIds = rows.map((r) => r.id);
+        let commentCountMap = new Map();
+        if (reviewIds.length > 0) {
+            const { inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            const countRows = await this.db
+                .select({
+                reviewId: reviewComments.reviewId,
+                count: count(),
+            })
+                .from(reviewComments)
+                .where(inArray(reviewComments.reviewId, reviewIds))
+                .groupBy(reviewComments.reviewId);
+            commentCountMap = new Map(countRows.map((r) => [r.reviewId, r.count]));
+        }
+        const items = rows.map((row) => ({
+            ...row,
+            commentCount: commentCountMap.get(row.id) ?? 0,
+        }));
+        return {
+            items,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async createReviewComment(data, targetAgentIds) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { reviewComments, reviewCommentTargets } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const sqlite = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        if (!sqlite || typeof sqlite.exec !== 'function') {
+            throw new error_types_1.StorageError('Unable to access underlying SQLite client');
+        }
+        sqlite.exec('BEGIN IMMEDIATE TRANSACTION');
+        try {
+            const comment = {
+                id: randomUUID(),
+                reviewId: data.reviewId,
+                filePath: data.filePath,
+                parentId: data.parentId,
+                lineStart: data.lineStart,
+                lineEnd: data.lineEnd,
+                side: data.side,
+                content: data.content,
+                commentType: data.commentType,
+                status: data.status,
+                authorType: data.authorType,
+                authorAgentId: data.authorAgentId,
+                version: 1,
+                editedAt: null,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await this.db.insert(reviewComments).values({
+                id: comment.id,
+                reviewId: comment.reviewId,
+                filePath: comment.filePath,
+                parentId: comment.parentId,
+                lineStart: comment.lineStart,
+                lineEnd: comment.lineEnd,
+                side: comment.side,
+                content: comment.content,
+                commentType: comment.commentType,
+                status: comment.status,
+                authorType: comment.authorType,
+                authorAgentId: comment.authorAgentId,
+                version: comment.version,
+                editedAt: comment.editedAt,
+                createdAt: comment.createdAt,
+                updatedAt: comment.updatedAt,
+            });
+            if (targetAgentIds && targetAgentIds.length > 0) {
+                for (const agentId of targetAgentIds) {
+                    await this.db.insert(reviewCommentTargets).values({
+                        id: randomUUID(),
+                        commentId: comment.id,
+                        agentId,
+                        createdAt: now,
+                    });
+                }
+            }
+            sqlite.exec('COMMIT');
+            logger.info({ commentId: comment.id, reviewId: comment.reviewId, targets: targetAgentIds?.length ?? 0 }, 'Created review comment');
+            return comment;
+        }
+        catch (error) {
+            try {
+                sqlite.exec('ROLLBACK');
+                logger.info('Transaction rolled back successfully');
+            }
+            catch (rollbackError) {
+                logger.error({ rollbackError }, 'Failed to rollback transaction');
+            }
+            throw error;
+        }
+    }
+    async getReviewComment(id) {
+        const { reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db
+            .select()
+            .from(reviewComments)
+            .where(eq(reviewComments.id, id))
+            .limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('ReviewComment', id);
+        }
+        return result[0];
+    }
+    async updateReviewComment(id, data, expectedVersion) {
+        const { reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const current = await this.getReviewComment(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('ReviewComment', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        const updateData = {};
+        if (data.content !== undefined && data.content !== current.content) {
+            updateData.content = data.content;
+            updateData.editedAt = now;
+        }
+        if (data.status !== undefined && data.status !== current.status) {
+            updateData.status = data.status;
+        }
+        if (Object.keys(updateData).length === 0) {
+            logger.info({ commentId: id }, 'Skipped review comment update (no changes)');
+            return current;
+        }
+        await this.db
+            .update(reviewComments)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(reviewComments.id, id));
+        logger.info({ commentId: id }, 'Updated review comment');
+        return this.getReviewComment(id);
+    }
+    async listReviewComments(reviewId, options = {}) {
+        const { reviewComments, agents, reviewCommentTargets } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, isNull, desc, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const conditions = [eq(reviewComments.reviewId, reviewId)];
+        if (options.status) {
+            conditions.push(eq(reviewComments.status, options.status));
+        }
+        if (options.filePath) {
+            conditions.push(eq(reviewComments.filePath, options.filePath));
+        }
+        if (options.parentId === null) {
+            conditions.push(isNull(reviewComments.parentId));
+        }
+        else if (options.parentId !== undefined) {
+            conditions.push(eq(reviewComments.parentId, options.parentId));
+        }
+        const rows = await this.db
+            .select()
+            .from(reviewComments)
+            .where(and(...conditions))
+            .orderBy(desc(reviewComments.createdAt))
+            .limit(limit)
+            .offset(offset);
+        if (rows.length === 0) {
+            return { items: [], total: 0, limit, offset };
+        }
+        const authorAgentIds = [
+            ...new Set(rows.map((r) => r.authorAgentId).filter((id) => typeof id === 'string')),
+        ];
+        const agentNameMap = new Map();
+        if (authorAgentIds.length > 0) {
+            const authorAgents = await this.db
+                .select({ id: agents.id, name: agents.name })
+                .from(agents)
+                .where(inArray(agents.id, authorAgentIds));
+            authorAgents.forEach((a) => agentNameMap.set(a.id, a.name));
+        }
+        const commentIds = rows.map((r) => r.id);
+        const targetsWithNames = await this.db
+            .select({
+            commentId: reviewCommentTargets.commentId,
+            agentId: reviewCommentTargets.agentId,
+            agentName: agents.name,
+        })
+            .from(reviewCommentTargets)
+            .leftJoin(agents, eq(reviewCommentTargets.agentId, agents.id))
+            .where(inArray(reviewCommentTargets.commentId, commentIds));
+        const targetsByCommentId = new Map();
+        targetsWithNames.forEach((t) => {
+            const list = targetsByCommentId.get(t.commentId) ?? [];
+            list.push({ agentId: t.agentId, name: t.agentName ?? 'Unknown' });
+            targetsByCommentId.set(t.commentId, list);
+        });
+        const enrichedItems = rows.map((row) => ({
+            ...row,
+            authorAgentName: row.authorAgentId ? (agentNameMap.get(row.authorAgentId) ?? null) : null,
+            targetAgents: targetsByCommentId.get(row.id) ?? [],
+        }));
+        return {
+            items: enrichedItems,
+            total: rows.length,
+            limit,
+            offset,
+        };
+    }
+    async addReviewCommentTargets(commentId, agentIds) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { reviewCommentTargets } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        await this.getReviewComment(commentId);
+        const targets = [];
+        for (const agentId of agentIds) {
+            const target = {
+                id: randomUUID(),
+                commentId,
+                agentId,
+                createdAt: now,
+            };
+            await this.db.insert(reviewCommentTargets).values(target);
+            targets.push(target);
+        }
+        logger.info({ commentId, count: targets.length }, 'Added review comment targets');
+        return targets;
+    }
+    async getReviewCommentTargets(commentId) {
+        const { reviewCommentTargets } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(reviewCommentTargets)
+            .where(eq(reviewCommentTargets.commentId, commentId));
+        return rows;
+    }
+    async deleteReviewComment(id) {
+        const { reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(reviewComments).where(eq(reviewComments.id, id));
+    }
+    async deleteNonResolvedComments(reviewId) {
+        const { reviewComments } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, notInArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const result = await this.db
+            .delete(reviewComments)
+            .where(and(eq(reviewComments.reviewId, reviewId), notInArray(reviewComments.status, ['resolved', 'wont_fix'])));
+        return result.changes ?? 0;
+    }
 };
 exports.LocalStorageService = LocalStorageService;
 exports.LocalStorageService = LocalStorageService = __decorate([