devchain-cli 0.2.1 → 0.3.1

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

@@ -100,6 +100,21 @@ let LocalStorageService = class LocalStorageService {
             }
         }
     }
+    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;
@@ -195,6 +210,7 @@ let LocalStorageService = class LocalStorageService {
                     label: s.label,
                     color: s.color,
                     position: s.position,
+                    mcpHidden: s.mcpHidden ?? false,
                     createdAt: now,
                     updatedAt: now,
                 });
@@ -516,6 +532,7 @@ let LocalStorageService = class LocalStorageService {
         const status = {
             id: randomUUID(),
             ...data,
+            mcpHidden: data.mcpHidden ?? false,
             createdAt: now,
             updatedAt: now,
         };
@@ -525,6 +542,7 @@ let LocalStorageService = class LocalStorageService {
             label: status.label,
             color: status.color,
             position: status.position,
+            mcpHidden: status.mcpHidden,
             createdAt: status.createdAt,
             updatedAt: status.updatedAt,
         });
@@ -729,6 +747,12 @@ let LocalStorageService = class LocalStorageService {
         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(*)` })
@@ -763,7 +787,14 @@ let LocalStorageService = class LocalStorageService {
         const limit = options.limit ?? 100;
         const offset = options.offset ?? 0;
         const agent = await this.getAgentByName(projectId, options.agentName);
-        const whereClause = and(eq(epics.projectId, projectId), eq(epics.agentId, agent.id));
+        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)
@@ -894,6 +925,120 @@ let LocalStorageService = class LocalStorageService {
             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.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 = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        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,
+                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 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;
+    }
     async countSubEpicsByStatus(parentId) {
         await this.getEpic(parentId);
         const { epics } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
@@ -1038,17 +1183,75 @@ let LocalStorageService = class LocalStorageService {
             tags: promptTagsResult.map((pt) => pt.tag.name),
         };
     }
-    async listPrompts(projectId, options = {}) {
-        const { prompts } = 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 query = projectId ? eq(prompts.projectId, projectId) : undefined;
-        const items = await this.db.select().from(prompts).where(query).limit(limit).offset(offset);
-        const itemsWithTags = await Promise.all(items.map((item) => this.getPrompt(item.id)));
+    async listPrompts(filters = {}) {
+        const { prompts, promptTags, tags } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq, isNull, desc, sql } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const whereClauses = [];
+        if (filters.projectId !== undefined) {
+            whereClauses.push(filters.projectId === null
+                ? isNull(prompts.projectId)
+                : eq(prompts.projectId, filters.projectId));
+        }
+        const searchTerm = filters.q?.trim();
+        if (searchTerm) {
+            const pattern = `%${searchTerm.toLowerCase()}%`;
+            whereClauses.push(sql `lower(${prompts.title}) LIKE ${pattern}`);
+        }
+        const whereCondition = whereClauses.length === 0
+            ? undefined
+            : whereClauses.length === 1
+                ? whereClauses[0]
+                : and(...whereClauses);
+        const selectFields = {
+            id: prompts.id,
+            projectId: prompts.projectId,
+            title: prompts.title,
+            content: prompts.content,
+            version: prompts.version,
+            createdAt: prompts.createdAt,
+            updatedAt: prompts.updatedAt,
+        };
+        const rows = await (whereCondition
+            ? this.db
+                .select(selectFields)
+                .from(prompts)
+                .where(whereCondition)
+                .orderBy(desc(prompts.updatedAt))
+            : this.db.select(selectFields).from(prompts).orderBy(desc(prompts.updatedAt)));
+        if (!rows.length) {
+            return {
+                items: [],
+                total: 0,
+                limit: filters.limit ?? 100,
+                offset: filters.offset ?? 0,
+            };
+        }
+        const PREVIEW_LENGTH = 200;
+        const promptsWithTags = await Promise.all(rows.map(async (row) => {
+            const tagRows = await this.db
+                .select({ tagName: tags.name })
+                .from(promptTags)
+                .innerJoin(tags, eq(tags.id, promptTags.tagId))
+                .where(eq(promptTags.promptId, row.id));
+            const content = row.content ?? '';
+            const contentPreview = content.length > PREVIEW_LENGTH ? content.slice(0, PREVIEW_LENGTH) + '…' : content;
+            return {
+                id: row.id,
+                projectId: row.projectId,
+                title: row.title,
+                contentPreview,
+                version: row.version,
+                tags: tagRows.map((t) => t.tagName),
+                createdAt: row.createdAt,
+                updatedAt: row.updatedAt,
+            };
+        }));
+        const limit = filters.limit ?? 100;
+        const offset = filters.offset ?? 0;
+        const items = promptsWithTags.slice(offset, offset + limit);
         return {
-            items: itemsWithTags,
-            total: items.length,
+            items,
+            total: promptsWithTags.length,
             limit,
             offset,
         };
@@ -2094,6 +2297,199 @@ let LocalStorageService = class LocalStorageService {
             });
         }
     }
+    async listWatchers(projectId) {
+        const { terminalWatchers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(terminalWatchers)
+            .where(eq(terminalWatchers.projectId, projectId))
+            .orderBy(desc(terminalWatchers.createdAt));
+        return rows.map((row) => ({
+            ...row,
+            condition: row.condition,
+        }));
+    }
+    async getWatcher(id) {
+        const { terminalWatchers } = 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(terminalWatchers)
+            .where(eq(terminalWatchers.id, id))
+            .limit(1);
+        if (!result[0]) {
+            return null;
+        }
+        return {
+            ...result[0],
+            condition: result[0].condition,
+        };
+    }
+    async createWatcher(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { terminalWatchers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const watcher = {
+            id: randomUUID(),
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(terminalWatchers).values({
+            id: watcher.id,
+            projectId: watcher.projectId,
+            name: watcher.name,
+            description: watcher.description,
+            enabled: watcher.enabled,
+            scope: watcher.scope,
+            scopeFilterId: watcher.scopeFilterId,
+            pollIntervalMs: watcher.pollIntervalMs,
+            viewportLines: watcher.viewportLines,
+            condition: watcher.condition,
+            cooldownMs: watcher.cooldownMs,
+            cooldownMode: watcher.cooldownMode,
+            eventName: watcher.eventName,
+            createdAt: watcher.createdAt,
+            updatedAt: watcher.updatedAt,
+        });
+        return watcher;
+    }
+    async updateWatcher(id, data) {
+        const { terminalWatchers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const existing = await this.getWatcher(id);
+        if (!existing) {
+            throw new error_types_1.NotFoundError('Watcher', id);
+        }
+        await this.db
+            .update(terminalWatchers)
+            .set({ ...data, updatedAt: now })
+            .where(eq(terminalWatchers.id, id));
+        const updated = await this.getWatcher(id);
+        if (!updated) {
+            throw new error_types_1.NotFoundError('Watcher', id);
+        }
+        return updated;
+    }
+    async deleteWatcher(id) {
+        const { terminalWatchers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(terminalWatchers).where(eq(terminalWatchers.id, id));
+    }
+    async listEnabledWatchers() {
+        const { terminalWatchers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(terminalWatchers)
+            .where(eq(terminalWatchers.enabled, true))
+            .orderBy(desc(terminalWatchers.createdAt));
+        return rows.map((row) => ({
+            ...row,
+            condition: row.condition,
+        }));
+    }
+    async listSubscribers(projectId) {
+        const { automationSubscribers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(automationSubscribers)
+            .where(eq(automationSubscribers.projectId, projectId))
+            .orderBy(desc(automationSubscribers.createdAt));
+        return rows.map((row) => ({
+            ...row,
+            eventFilter: row.eventFilter,
+            actionInputs: row.actionInputs,
+        }));
+    }
+    async getSubscriber(id) {
+        const { automationSubscribers } = 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(automationSubscribers)
+            .where(eq(automationSubscribers.id, id))
+            .limit(1);
+        if (!result[0]) {
+            return null;
+        }
+        return {
+            ...result[0],
+            eventFilter: result[0].eventFilter,
+            actionInputs: result[0].actionInputs,
+        };
+    }
+    async createSubscriber(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const { automationSubscribers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const subscriber = {
+            id: randomUUID(),
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(automationSubscribers).values({
+            id: subscriber.id,
+            projectId: subscriber.projectId,
+            name: subscriber.name,
+            description: subscriber.description,
+            enabled: subscriber.enabled,
+            eventName: subscriber.eventName,
+            eventFilter: subscriber.eventFilter,
+            actionType: subscriber.actionType,
+            actionInputs: subscriber.actionInputs,
+            delayMs: subscriber.delayMs,
+            cooldownMs: subscriber.cooldownMs,
+            retryOnError: subscriber.retryOnError,
+            groupName: subscriber.groupName,
+            position: subscriber.position,
+            priority: subscriber.priority,
+            createdAt: subscriber.createdAt,
+            updatedAt: subscriber.updatedAt,
+        });
+        return subscriber;
+    }
+    async updateSubscriber(id, data) {
+        const { automationSubscribers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        const existing = await this.getSubscriber(id);
+        if (!existing) {
+            throw new error_types_1.NotFoundError('Subscriber', id);
+        }
+        await this.db
+            .update(automationSubscribers)
+            .set({ ...data, updatedAt: now })
+            .where(eq(automationSubscribers.id, id));
+        const updated = await this.getSubscriber(id);
+        if (!updated) {
+            throw new error_types_1.NotFoundError('Subscriber', id);
+        }
+        return updated;
+    }
+    async deleteSubscriber(id) {
+        const { automationSubscribers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.delete(automationSubscribers).where(eq(automationSubscribers.id, id));
+    }
+    async findSubscribersByEventName(projectId, eventName) {
+        const { automationSubscribers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq, and, desc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(automationSubscribers)
+            .where(and(eq(automationSubscribers.projectId, projectId), eq(automationSubscribers.eventName, eventName), eq(automationSubscribers.enabled, true)))
+            .orderBy(desc(automationSubscribers.createdAt));
+        return rows.map((row) => ({
+            ...row,
+            eventFilter: row.eventFilter,
+            actionInputs: row.actionInputs,
+        }));
+    }
 };
 exports.LocalStorageService = LocalStorageService;
 exports.LocalStorageService = LocalStorageService = __decorate([