devchain-cli 0.10.5 → 0.11.0

package/dist/server/modules/storage/local/delegates/epic.delegate.js

@@ -0,0 +1,686 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpicStorageDelegate = void 0;
+const error_types_1 = require("../../../../common/errors/error-types");
+const logger_1 = require("../../../../common/logging/logger");
+const storage_helpers_1 = require("../helpers/storage-helpers");
+const base_storage_delegate_1 = require("./base-storage.delegate");
+const logger = (0, logger_1.createLogger)('EpicStorageDelegate');
+class EpicStorageDelegate extends base_storage_delegate_1.BaseStorageDelegate {
+    constructor(context, dependencies) {
+        super(context);
+        this.dependencies = dependencies;
+    }
+    async createEpic(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { epics, epicTags, tags } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const epicId = randomUUID();
+        await this.ensureValidEpicParent(data.projectId, data.parentId ?? null, epicId);
+        await this.ensureValidAgent(data.projectId, data.agentId ?? null);
+        const epic = {
+            id: epicId,
+            projectId: data.projectId,
+            title: data.title,
+            description: data.description ?? null,
+            statusId: data.statusId,
+            parentId: data.parentId ?? null,
+            agentId: data.agentId ?? null,
+            version: 1,
+            data: data.data ?? null,
+            skillsRequired: data.skillsRequired ?? null,
+            tags: data.tags ?? [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(epics).values({
+            id: epic.id,
+            projectId: epic.projectId,
+            title: epic.title,
+            description: epic.description,
+            statusId: epic.statusId,
+            parentId: epic.parentId,
+            agentId: epic.agentId,
+            version: epic.version,
+            data: epic.data ? JSON.stringify(epic.data) : null,
+            skillsRequired: (0, storage_helpers_1.serializeSkillsRequired)(epic.skillsRequired),
+            createdAt: epic.createdAt,
+            updatedAt: epic.updatedAt,
+        });
+        if (epic.tags.length) {
+            for (const tagName of epic.tags) {
+                const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+                let tag = await this.db
+                    .select()
+                    .from(tags)
+                    .where(and(eq(tags.name, tagName), or(eq(tags.projectId, data.projectId), isNull(tags.projectId))))
+                    .limit(1);
+                if (!tag[0]) {
+                    const newTag = await this.dependencies.createTag({
+                        projectId: data.projectId,
+                        name: tagName,
+                    });
+                    tag = [newTag];
+                }
+                await this.db.insert(epicTags).values({
+                    epicId: epic.id,
+                    tagId: tag[0].id,
+                    createdAt: now,
+                });
+            }
+        }
+        return epic;
+    }
+    async getEpic(id) {
+        const { epics, epicTags, tags } = 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(epics).where(eq(epics.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Epic', id);
+        }
+        const epicTagsResult = await this.db
+            .select({ tag: tags })
+            .from(epicTags)
+            .innerJoin(tags, eq(epicTags.tagId, tags.id))
+            .where(eq(epicTags.epicId, id));
+        return {
+            ...result[0],
+            data: result[0].data,
+            skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(result[0].skillsRequired),
+            tags: epicTagsResult.map((et) => et.tag.name),
+        };
+    }
+    async listEpics(projectId, options = {}) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.projectId, projectId))
+            .limit(limit)
+            .offset(offset);
+        const epicIds = items.map((item) => item.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const itemsWithTags = items.map((item) => ({
+            ...item,
+            data: item.data,
+            skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(item.skillsRequired),
+            tags: tagsMap.get(item.id) ?? [],
+        }));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async listEpicsByStatus(statusId, options = {}) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.statusId, statusId))
+            .limit(limit)
+            .offset(offset);
+        const epicIds = items.map((item) => item.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const itemsWithTags = items.map((item) => ({
+            ...item,
+            data: item.data,
+            skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(item.skillsRequired),
+            tags: tagsMap.get(item.id) ?? [],
+        }));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async listProjectEpics(projectId, options = {}) {
+        const { epics, statuses } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, and, sql, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const conditions = [eq(epics.projectId, projectId)];
+        if (options.q) {
+            const search = options.q.trim().toLowerCase();
+            if (search.length) {
+                const pattern = `%${search}%`;
+                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) {
+            conditions.push(eq(epics.statusId, options.statusId));
+        }
+        const listType = (options.type ?? 'active').toLowerCase();
+        let archivedFilter = null;
+        if (listType === 'active') {
+            archivedFilter = sql `lower(${statuses.label}) NOT LIKE '%archiv%'`;
+        }
+        else if (listType === 'archived') {
+            archivedFilter = sql `lower(${statuses.label}) LIKE '%archiv%'`;
+        }
+        if (archivedFilter) {
+            conditions.push(archivedFilter);
+        }
+        if (options.excludeMcpHidden) {
+            conditions.push(await this.buildMcpHiddenExclusionPredicate(projectId, epics));
+        }
+        if (options.parentOnly) {
+            conditions.push(sql `${epics.parentId} IS NULL`);
+        }
+        const whereClause = and(...conditions);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epics)
+            .innerJoin(statuses, eq(statuses.id, epics.statusId))
+            .where(whereClause);
+        const total = Number(totalResult[0]?.count ?? 0);
+        const rows = await this.db
+            .select({ epic: epics })
+            .from(epics)
+            .innerJoin(statuses, eq(statuses.id, epics.statusId))
+            .where(whereClause)
+            .orderBy(desc(epics.updatedAt))
+            .limit(limit)
+            .offset(offset);
+        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,
+            skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(row.epic.skillsRequired),
+            tags: tagsMap.get(row.epic.id) ?? [],
+        }));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async listAssignedEpics(projectId, options) {
+        if (!options.agentName?.trim()) {
+            throw new error_types_1.ValidationError('agentName is required to list assigned epics.', {
+                projectId,
+            });
+        }
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { and, eq, sql, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const agent = await this.dependencies.getAgentByName(projectId, options.agentName);
+        const conditions = [
+            eq(epics.projectId, projectId),
+            eq(epics.agentId, agent.id),
+        ];
+        if (options.excludeMcpHidden) {
+            conditions.push(await this.buildMcpHiddenExclusionPredicate(projectId, epics));
+        }
+        const whereClause = and(...conditions);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epics)
+            .where(whereClause);
+        const total = Number(totalResult[0]?.count ?? 0);
+        const rows = await this.db
+            .select()
+            .from(epics)
+            .where(whereClause)
+            .orderBy(desc(epics.updatedAt))
+            .limit(limit)
+            .offset(offset);
+        const epicIds = rows.map((row) => row.id);
+        const tagsMap = await this.batchFetchTags(epicIds);
+        const items = rows.map((row) => ({
+            ...row,
+            data: row.data,
+            skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(row.skillsRequired),
+            tags: tagsMap.get(row.id) ?? [],
+        }));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async createEpicForProject(projectId, input) {
+        const { statuses } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        let statusId = input.statusId ?? null;
+        if (statusId) {
+            const status = await this.dependencies.getStatus(statusId);
+            if (status.projectId !== projectId) {
+                throw new error_types_1.ValidationError('Status must belong to the target project.', {
+                    statusId,
+                    projectId,
+                    statusProjectId: status.projectId,
+                });
+            }
+        }
+        else {
+            const defaultStatusResult = await this.db
+                .select({ id: statuses.id })
+                .from(statuses)
+                .where(eq(statuses.projectId, projectId))
+                .orderBy(asc(statuses.position))
+                .limit(1);
+            const defaultStatus = defaultStatusResult[0];
+            if (!defaultStatus) {
+                throw new error_types_1.ValidationError('Project has no statuses configured.', { projectId });
+            }
+            statusId = defaultStatus.id;
+        }
+        let agentId = input.agentId ?? null;
+        if (!agentId && input.agentName?.trim()) {
+            const agent = await this.dependencies.getAgentByName(projectId, input.agentName);
+            agentId = agent.id;
+        }
+        await this.ensureValidAgent(projectId, agentId);
+        await this.ensureValidEpicParent(projectId, input.parentId ?? null);
+        return this.createEpic({
+            projectId,
+            title: input.title,
+            description: input.description ?? null,
+            statusId,
+            parentId: input.parentId ?? null,
+            agentId,
+            skillsRequired: input.skillsRequired ?? null,
+            tags: input.tags ?? [],
+            data: null,
+        });
+    }
+    async updateEpic(id, data, expectedVersion) {
+        const { epics } = 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.getEpic(id);
+        if (current.version !== expectedVersion) {
+            throw new error_types_1.OptimisticLockError('Epic', id, {
+                expectedVersion,
+                actualVersion: current.version,
+            });
+        }
+        if (data.parentId !== undefined) {
+            await this.ensureValidEpicParent(current.projectId, data.parentId ?? null, id);
+        }
+        if (data.agentId !== undefined) {
+            await this.ensureValidAgent(current.projectId, data.agentId ?? null);
+        }
+        const updateData = { ...data };
+        if (data.data !== undefined) {
+            updateData.data = JSON.stringify(data.data);
+        }
+        if (data.skillsRequired !== undefined) {
+            updateData.skillsRequired = (0, storage_helpers_1.serializeSkillsRequired)(data.skillsRequired);
+        }
+        for (const key of Object.keys(updateData)) {
+            if (updateData[key] === undefined) {
+                delete updateData[key];
+            }
+        }
+        await this.db
+            .update(epics)
+            .set({ ...updateData, version: expectedVersion + 1, updatedAt: now })
+            .where(eq(epics.id, id));
+        return this.getEpic(id);
+    }
+    async deleteEpic(id) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const subEpics = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .where(eq(epics.parentId, id));
+        for (const subEpic of subEpics) {
+            await this.deleteEpic(subEpic.id);
+        }
+        await this.db.delete(epics).where(eq(epics.id, id));
+        logger.info({ epicId: id, deletedSubEpics: subEpics.length }, 'Deleted epic and sub-epics');
+    }
+    async listSubEpics(parentId, options = {}) {
+        await this.getEpic(parentId);
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epics)
+            .where(eq(epics.parentId, parentId))
+            .limit(limit)
+            .offset(offset);
+        const itemsWithTags = await Promise.all(items.map((item) => this.getEpic(item.id)));
+        return {
+            items: itemsWithTags,
+            total: items.length,
+            limit,
+            offset,
+        };
+    }
+    async listSubEpicsForParents(projectId, parentIds, options = {}) {
+        const result = new Map();
+        for (const parentId of parentIds) {
+            result.set(parentId, []);
+        }
+        if (parentIds.length === 0) {
+            return result;
+        }
+        const limitPerParent = options.limitPerParent ?? 50;
+        const listType = (options.type ?? 'active').toLowerCase();
+        let archivedCondition = '';
+        if (listType === 'active') {
+            archivedCondition = "AND lower(s.label) NOT LIKE '%archiv%'";
+        }
+        else if (listType === 'archived') {
+            archivedCondition = "AND lower(s.label) LIKE '%archiv%'";
+        }
+        const mcpHiddenCondition = options.excludeMcpHidden ? 'AND s.mcp_hidden != 1' : '';
+        const parentIdPlaceholders = parentIds.map(() => '?').join(', ');
+        const queryStr = `
+      WITH ranked AS (
+        SELECT
+          e.id,
+          e.project_id,
+          e.title,
+          e.description,
+          e.status_id,
+          e.parent_id,
+          e.agent_id,
+          e.version,
+          e.data,
+          e.skills_required,
+          e.created_at,
+          e.updated_at,
+          ROW_NUMBER() OVER (
+            PARTITION BY e.parent_id
+            ORDER BY e.updated_at DESC, e.id DESC
+          ) as row_num
+        FROM epics e
+        INNER JOIN statuses s ON s.id = e.status_id
+        WHERE e.project_id = ?
+          AND e.parent_id IN (${parentIdPlaceholders})
+          ${archivedCondition}
+          ${mcpHiddenCondition}
+      )
+      SELECT * FROM ranked WHERE row_num <= ?
+      ORDER BY parent_id, row_num
+    `;
+        const sqlite = this.rawClient;
+        if (!sqlite || typeof sqlite.prepare !== 'function') {
+            throw new error_types_1.StorageError('Unable to access underlying SQLite client for sub-epic batching');
+        }
+        const stmt = sqlite.prepare(queryStr);
+        const rows = stmt.all(projectId, ...parentIds, limitPerParent);
+        const allEpics = [];
+        for (const row of rows) {
+            if (!row.parent_id)
+                continue;
+            const epic = {
+                id: row.id,
+                projectId: row.project_id,
+                title: row.title,
+                description: row.description,
+                statusId: row.status_id,
+                parentId: row.parent_id,
+                agentId: row.agent_id,
+                version: row.version,
+                data: row.data ? JSON.parse(row.data) : null,
+                skillsRequired: (0, storage_helpers_1.parseSkillsRequired)(row.skills_required),
+                tags: [],
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+            };
+            allEpics.push(epic);
+            const group = result.get(row.parent_id) ?? [];
+            group.push(epic);
+            result.set(row.parent_id, group);
+        }
+        if (allEpics.length > 0) {
+            const epicIds = allEpics.map((e) => e.id);
+            const tagsMap = await this.batchFetchTags(epicIds);
+            for (const epic of allEpics) {
+                epic.tags = tagsMap.get(epic.id) ?? [];
+            }
+        }
+        return result;
+    }
+    async countSubEpicsByStatus(parentId) {
+        await this.getEpic(parentId);
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({ statusId: epics.statusId })
+            .from(epics)
+            .where(eq(epics.parentId, parentId));
+        return rows.reduce((acc, row) => {
+            const key = row.statusId;
+            acc[key] = (acc[key] ?? 0) + 1;
+            return acc;
+        }, {});
+    }
+    async countEpicsByStatus(statusId) {
+        const { epics } = 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({ count: count() })
+            .from(epics)
+            .where(eq(epics.statusId, statusId));
+        return Number(result[0]?.count ?? 0);
+    }
+    async updateEpicsStatus(oldStatusId, newStatusId) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const result = await this.db
+            .update(epics)
+            .set({ statusId: newStatusId, updatedAt: now })
+            .where(eq(epics.statusId, oldStatusId));
+        return result.changes ?? 0;
+    }
+    async listEpicComments(epicId, options = {}) {
+        await this.getEpic(epicId);
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, asc, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const limit = options.limit || 100;
+        const offset = options.offset || 0;
+        const items = await this.db
+            .select()
+            .from(epicComments)
+            .where(eq(epicComments.epicId, epicId))
+            .orderBy(asc(epicComments.createdAt))
+            .limit(limit)
+            .offset(offset);
+        const totalResult = await this.db
+            .select({ count: sql `count(*)` })
+            .from(epicComments)
+            .where(eq(epicComments.epicId, epicId));
+        const total = Number(totalResult[0]?.count ?? 0);
+        return {
+            items: items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async createEpicComment(data) {
+        await this.getEpic(data.epicId);
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const now = new Date().toISOString();
+        const comment = {
+            id: randomUUID(),
+            epicId: data.epicId,
+            authorName: data.authorName,
+            content: data.content,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(epicComments).values({
+            id: comment.id,
+            epicId: comment.epicId,
+            authorName: comment.authorName,
+            content: comment.content,
+            createdAt: comment.createdAt,
+            updatedAt: comment.updatedAt,
+        });
+        return comment;
+    }
+    async deleteEpicComment(id) {
+        const { epicComments } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(epicComments).where(eq(epicComments.id, id));
+    }
+    async getEpicsByIdPrefix(projectId, prefix) {
+        const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, and, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        return this.db
+            .select({ id: epics.id, title: epics.title })
+            .from(epics)
+            .where(and(eq(epics.projectId, projectId), sql `substr(${epics.id}, 1, ${prefix.length}) = ${prefix}`));
+    }
+    async ensureValidEpicParent(projectId, parentId, childId) {
+        if (!parentId) {
+            return;
+        }
+        if (childId && parentId === childId) {
+            throw new error_types_1.ValidationError('An epic cannot be its own parent.', {
+                epicId: childId,
+                parentId,
+            });
+        }
+        const parent = await this.getEpic(parentId);
+        if (parent.projectId !== projectId) {
+            throw new error_types_1.ValidationError('Parent epic must belong to the same project.', {
+                projectId,
+                parentProjectId: parent.projectId,
+                parentId,
+            });
+        }
+        if (parent.parentId) {
+            throw new error_types_1.ValidationError('Cannot assign a sub-epic as a parent (one-level hierarchy).', {
+                parentId,
+            });
+        }
+        if (childId) {
+            const { epics } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+            const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            const descendants = await this.db
+                .select({ id: epics.id })
+                .from(epics)
+                .where(eq(epics.parentId, childId));
+            if (descendants.some((row) => row.id === parentId)) {
+                throw new error_types_1.ValidationError('Cannot assign a descendant as the parent epic.', {
+                    parentId,
+                    epicId: childId,
+                });
+            }
+        }
+    }
+    async buildMcpHiddenExclusionPredicate(projectId, epicsTable) {
+        const { sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        return sql `${epicsTable.id} NOT IN (
+      WITH RECURSIVE excluded_tree AS (
+        SELECT e.id FROM epics e
+        JOIN statuses s ON e.status_id = s.id
+        WHERE s.mcp_hidden = 1 AND e.project_id = ${projectId}
+        UNION ALL
+        SELECT e.id FROM epics e
+        JOIN excluded_tree et ON e.parent_id = et.id
+        WHERE e.project_id = ${projectId}
+      )
+      SELECT id FROM excluded_tree
+    )`;
+    }
+    async ensureValidAgent(projectId, agentId) {
+        if (!agentId) {
+            return;
+        }
+        const agent = await this.dependencies.getAgent(agentId);
+        if (agent.projectId !== projectId) {
+            throw new error_types_1.ValidationError('Agent must belong to the same project as the epic.', {
+                projectId,
+                agentProjectId: agent.projectId,
+                agentId,
+            });
+        }
+    }
+    async batchFetchTags(epicIds) {
+        const tagsMap = new Map();
+        if (epicIds.length === 0) {
+            return tagsMap;
+        }
+        const { epicTags, tags } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const CHUNK_SIZE = 500;
+        const chunks = [];
+        for (let i = 0; i < epicIds.length; i += CHUNK_SIZE) {
+            chunks.push(epicIds.slice(i, i + CHUNK_SIZE));
+        }
+        for (const chunk of chunks) {
+            const rows = await this.db
+                .select({
+                epicId: epicTags.epicId,
+                tagName: tags.name,
+            })
+                .from(epicTags)
+                .innerJoin(tags, eq(epicTags.tagId, tags.id))
+                .where(inArray(epicTags.epicId, chunk));
+            for (const row of rows) {
+                const existing = tagsMap.get(row.epicId) ?? [];
+                existing.push(row.tagName);
+                tagsMap.set(row.epicId, existing);
+            }
+        }
+        return tagsMap;
+    }
+}
+exports.EpicStorageDelegate = EpicStorageDelegate;
+//# sourceMappingURL=epic.delegate.js.map