devchain-cli 0.10.4 → 0.11.0

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

@@ -0,0 +1,630 @@
+"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.ProjectStorageDelegate = void 0;
+const error_types_1 = require("../../../../common/errors/error-types");
+const logger_1 = require("../../../../common/logging/logger");
+const sqlite_raw_1 = require("../../db/sqlite-raw");
+const storage_helpers_1 = require("../helpers/storage-helpers");
+const base_storage_delegate_1 = require("./base-storage.delegate");
+const logger = (0, logger_1.createLogger)('ProjectStorageDelegate');
+class ProjectStorageDelegate extends base_storage_delegate_1.BaseStorageDelegate {
+    constructor(context) {
+        super(context);
+    }
+    async listSeedableSourceNamesForNewProject() {
+        const { communitySkillSources } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const communitySourceRows = await this.db
+            .select({ name: communitySkillSources.name })
+            .from(communitySkillSources);
+        const sourceNames = communitySourceRows
+            .map((row) => row.name.trim().toLowerCase())
+            .filter((name) => name.length > 0);
+        const sqlite = this.rawClient;
+        if (sqlite && typeof sqlite.prepare === 'function') {
+            try {
+                const localRows = sqlite.prepare('SELECT name FROM local_skill_sources').all();
+                for (const row of localRows) {
+                    if (typeof row.name !== 'string') {
+                        continue;
+                    }
+                    const normalized = row.name.trim().toLowerCase();
+                    if (normalized.length > 0) {
+                        sourceNames.push(normalized);
+                    }
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (!message.includes('no such table: local_skill_sources')) {
+                    throw new error_types_1.StorageError('Failed to list local skill sources for project source seeding.', {
+                        cause: message,
+                    });
+                }
+            }
+        }
+        return [...new Set(sourceNames)];
+    }
+    async createProject(data) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const project = {
+            id: randomUUID(),
+            ...data,
+            isTemplate: data.isTemplate ?? false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const seedableSourceNames = await this.listSeedableSourceNamesForNewProject();
+        const { projects, statuses, sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        await this.db.transaction(async (tx) => {
+            await tx.insert(projects).values({
+                id: project.id,
+                name: project.name,
+                description: project.description,
+                rootPath: project.rootPath,
+                isTemplate: project.isTemplate,
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            });
+            const defaultStatuses = [
+                { label: 'Proposed', color: '#6c757d', position: 0 },
+                { label: 'In Progress', color: '#007bff', position: 1 },
+                { label: 'Review', color: '#ffc107', position: 2 },
+                { label: 'Done', color: '#28a745', position: 3 },
+                { label: 'Blocked', color: '#dc3545', position: 4 },
+            ];
+            for (const status of defaultStatuses) {
+                await tx.insert(statuses).values({
+                    id: randomUUID(),
+                    projectId: project.id,
+                    label: status.label,
+                    color: status.color,
+                    position: status.position,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+            }
+            if (seedableSourceNames.length > 0) {
+                await tx.insert(sourceProjectEnabled).values(seedableSourceNames.map((sourceName) => ({
+                    id: randomUUID(),
+                    projectId: project.id,
+                    sourceName,
+                    enabled: true,
+                    createdAt: now,
+                })));
+            }
+        });
+        logger.info({ projectId: project.id }, 'Created project with default statuses (transactional)');
+        return project;
+    }
+    async createProjectWithTemplate(data, template, options) {
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const providedProjectId = options?.projectId?.trim();
+        const project = {
+            id: providedProjectId || randomUUID(),
+            ...data,
+            isTemplate: data.isTemplate ?? false,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const seedableSourceNames = await this.listSeedableSourceNamesForNewProject();
+        const { projects, statuses, prompts, agentProfiles, agents, tags, promptTags, profileProviderConfigs, providers, sourceProjectEnabled, } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const statusIdMap = {};
+        const promptIdMap = {};
+        const profileIdMap = {};
+        const configIdMap = {};
+        const agentIdMap = {};
+        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 for transaction control');
+        }
+        sqlite.exec('BEGIN IMMEDIATE TRANSACTION');
+        try {
+            await this.db.insert(projects).values({
+                id: project.id,
+                name: project.name,
+                description: project.description,
+                rootPath: project.rootPath,
+                isTemplate: project.isTemplate,
+                createdAt: project.createdAt,
+                updatedAt: project.updatedAt,
+            });
+            for (const s of template.statuses.sort((a, b) => a.position - b.position)) {
+                const statusId = randomUUID();
+                await this.db.insert(statuses).values({
+                    id: statusId,
+                    projectId: project.id,
+                    label: s.label,
+                    color: s.color,
+                    position: s.position,
+                    mcpHidden: s.mcpHidden ?? false,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (s.id)
+                    statusIdMap[s.id] = statusId;
+            }
+            if (seedableSourceNames.length > 0) {
+                await this.db.insert(sourceProjectEnabled).values(seedableSourceNames.map((sourceName) => ({
+                    id: randomUUID(),
+                    projectId: project.id,
+                    sourceName,
+                    enabled: true,
+                    createdAt: now,
+                })));
+            }
+            const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            for (const p of template.prompts) {
+                const promptId = randomUUID();
+                await this.db.insert(prompts).values({
+                    id: promptId,
+                    projectId: project.id,
+                    title: p.title,
+                    content: p.content ?? '',
+                    version: 1,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (p.id)
+                    promptIdMap[p.id] = promptId;
+                if (p.tags?.length) {
+                    for (const tagName of p.tags) {
+                        let tag = await this.db
+                            .select()
+                            .from(tags)
+                            .where(and(eq(tags.name, tagName), or(eq(tags.projectId, project.id), isNull(tags.projectId))))
+                            .limit(1);
+                        if (!tag[0]) {
+                            const tagId = randomUUID();
+                            await this.db.insert(tags).values({
+                                id: tagId,
+                                projectId: project.id,
+                                name: tagName,
+                                createdAt: now,
+                                updatedAt: now,
+                            });
+                            tag = [
+                                { id: tagId, projectId: project.id, name: tagName, createdAt: now, updatedAt: now },
+                            ];
+                        }
+                        await this.db.insert(promptTags).values({
+                            promptId,
+                            tagId: tag[0].id,
+                            createdAt: now,
+                        });
+                    }
+                }
+            }
+            for (const prof of template.profiles) {
+                const profileId = randomUUID();
+                await this.db.insert(agentProfiles).values({
+                    id: profileId,
+                    projectId: project.id,
+                    name: prof.name,
+                    familySlug: prof.familySlug ?? null,
+                    systemPrompt: null,
+                    instructions: prof.instructions,
+                    temperature: prof.temperature != null ? Math.round(prof.temperature * 100) : null,
+                    maxTokens: prof.maxTokens,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (prof.id)
+                    profileIdMap[prof.id] = profileId;
+                if (prof.providerConfigs && prof.providerConfigs.length > 0) {
+                    const sortedConfigs = [...prof.providerConfigs].sort((a, b) => {
+                        const posA = a.position ?? 0;
+                        const posB = b.position ?? 0;
+                        return posA - posB;
+                    });
+                    for (const config of sortedConfigs) {
+                        const provider = await this.db
+                            .select()
+                            .from(providers)
+                            .where(eq(providers.name, config.providerName))
+                            .limit(1);
+                        if (!provider[0]) {
+                            throw new error_types_1.ValidationError(`Provider not found: ${config.providerName}`);
+                        }
+                        const configId = randomUUID();
+                        await this.db.insert(profileProviderConfigs).values({
+                            id: configId,
+                            profileId: profileId,
+                            providerId: provider[0].id,
+                            name: config.name,
+                            options: config.options ?? null,
+                            env: config.env ? JSON.stringify(config.env) : null,
+                            position: config.position ?? sortedConfigs.indexOf(config),
+                            createdAt: now,
+                            updatedAt: now,
+                        });
+                        if (!configIdMap[profileId]) {
+                            configIdMap[profileId] = configId;
+                        }
+                    }
+                }
+                else {
+                    const configId = randomUUID();
+                    await this.db.insert(profileProviderConfigs).values({
+                        id: configId,
+                        profileId: profileId,
+                        providerId: prof.providerId,
+                        name: prof.name,
+                        options: prof.options ?? null,
+                        env: null,
+                        position: 0,
+                        createdAt: now,
+                        updatedAt: now,
+                    });
+                    configIdMap[profileId] = configId;
+                }
+            }
+            for (const a of template.agents) {
+                const oldProfileId = a.profileId ?? '';
+                const newProfileId = oldProfileId && profileIdMap[oldProfileId] ? profileIdMap[oldProfileId] : undefined;
+                if (!newProfileId) {
+                    throw new error_types_1.ValidationError(`Profile mapping missing for agent ${a.name}`, {
+                        profileId: oldProfileId || null,
+                    });
+                }
+                const configId = configIdMap[newProfileId];
+                if (!configId) {
+                    throw new error_types_1.ValidationError(`Config mapping missing for agent ${a.name}`, {
+                        profileId: newProfileId,
+                    });
+                }
+                const agentId = randomUUID();
+                await this.db.insert(agents).values({
+                    id: agentId,
+                    projectId: project.id,
+                    name: a.name,
+                    profileId: newProfileId,
+                    providerConfigId: configId,
+                    description: a.description ?? null,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                if (a.id)
+                    agentIdMap[a.id] = agentId;
+            }
+            sqlite.exec('COMMIT');
+            logger.info({ projectId: project.id, counts: template }, 'Created project with template (transactional)');
+        }
+        catch (error) {
+            try {
+                sqlite.exec('ROLLBACK');
+                logger.info({ projectId: project.id }, 'Transaction rolled back successfully');
+            }
+            catch (rollbackError) {
+                logger.error({ rollbackError }, 'Failed to rollback transaction');
+            }
+            logger.error({ error, projectId: project.id }, 'Transaction failed');
+            const errorMessage = error instanceof Error ? error.message : '';
+            if (providedProjectId &&
+                (0, storage_helpers_1.isSqliteUniqueConstraint)(error) &&
+                errorMessage.includes('projects.id')) {
+                throw new error_types_1.ConflictError(`Project ID "${providedProjectId}" already exists.`, {
+                    field: 'projectId',
+                    projectId: providedProjectId,
+                });
+            }
+            throw error;
+        }
+        return {
+            project,
+            imported: {
+                prompts: template.prompts.length,
+                profiles: template.profiles.length,
+                agents: template.agents.length,
+                statuses: template.statuses.length,
+            },
+            mappings: {
+                promptIdMap,
+                profileIdMap,
+                agentIdMap,
+                statusIdMap,
+            },
+            initialPromptSet: false,
+        };
+    }
+    async getProject(id) {
+        const { projects } = 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(projects).where(eq(projects.id, id)).limit(1);
+        if (!result[0]) {
+            throw new error_types_1.NotFoundError('Project', id);
+        }
+        const row = result[0];
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async findProjectByPath(path) {
+        const { projects } = 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(projects)
+            .where(eq(projects.rootPath, path))
+            .limit(1);
+        if (!result[0])
+            return null;
+        const row = result[0];
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    async getProjectByRootPath(rootPath) {
+        const { resolve } = await Promise.resolve().then(() => __importStar(require('path')));
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const normalizedPath = resolve(rootPath);
+        const rows = await this.db
+            .select()
+            .from(projects)
+            .where(eq(projects.rootPath, normalizedPath))
+            .limit(1);
+        if (rows.length === 0) {
+            return null;
+        }
+        return {
+            id: rows[0].id,
+            name: rows[0].name,
+            description: rows[0].description,
+            rootPath: rows[0].rootPath,
+            isTemplate: rows[0].isTemplate,
+            createdAt: rows[0].createdAt,
+            updatedAt: rows[0].updatedAt,
+        };
+    }
+    async findProjectContainingPath(absolutePath) {
+        const { resolve, sep } = await Promise.resolve().then(() => __importStar(require('path')));
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const normalizedPath = resolve(absolutePath);
+        const allProjects = [];
+        const pageSize = 100;
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const rows = await this.db.select().from(projects).limit(pageSize).offset(offset);
+            if (rows.length === 0) {
+                hasMore = false;
+            }
+            else {
+                for (const row of rows) {
+                    allProjects.push({
+                        id: row.id,
+                        name: row.name,
+                        description: row.description,
+                        rootPath: row.rootPath,
+                        isTemplate: row.isTemplate,
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt,
+                    });
+                }
+                offset += pageSize;
+                if (rows.length < pageSize) {
+                    hasMore = false;
+                }
+            }
+        }
+        let bestMatch = null;
+        let longestRootPath = 0;
+        for (const project of allProjects) {
+            const projectRoot = resolve(project.rootPath);
+            if (normalizedPath === projectRoot || normalizedPath.startsWith(projectRoot + sep)) {
+                if (projectRoot.length > longestRootPath) {
+                    longestRootPath = projectRoot.length;
+                    bestMatch = project;
+                }
+            }
+        }
+        return bestMatch;
+    }
+    async listProjects(options = {}) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { 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(projects).limit(limit).offset(offset);
+        const countResult = await this.db.select({ count: sql `count(*)` }).from(projects);
+        const total = Number(countResult[0]?.count ?? 0);
+        const mapped = items.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description ?? null,
+            rootPath: row.rootPath,
+            isTemplate: Boolean(row.isTemplate ?? false),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        }));
+        return {
+            items: mapped,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async updateProject(id, data) {
+        const { projects } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const now = new Date().toISOString();
+        await this.db
+            .update(projects)
+            .set({ ...data, updatedAt: now })
+            .where(eq(projects.id, id));
+        return this.getProject(id);
+    }
+    async deleteProject(id) {
+        const { projects, chatThreads, chatMessages, chatMembers, chatMessageTargets, chatMessageReads, chatThreadSessionInvites, chatActivities, sessions, transcripts, epicComments, records, recordTags, epicTags, epics, documents, documentTags, prompts, promptTags, agentProfilePrompts, agents, agentProfiles, tags, statuses, guests, } = await Promise.resolve().then(() => __importStar(require('../../db/schema')));
+        const { eq, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const projectEpics = await this.db
+            .select({ id: epics.id })
+            .from(epics)
+            .where(eq(epics.projectId, id));
+        const epicIds = projectEpics.map((e) => e.id);
+        const projectChatThreads = await this.db
+            .select({ id: chatThreads.id })
+            .from(chatThreads)
+            .where(eq(chatThreads.projectId, id));
+        const threadIds = projectChatThreads.map((t) => t.id);
+        const projectMessages = threadIds.length > 0
+            ? await this.db
+                .select({ id: chatMessages.id })
+                .from(chatMessages)
+                .where(inArray(chatMessages.threadId, threadIds))
+            : [];
+        const messageIds = projectMessages.map((m) => m.id);
+        const projectAgents = await this.db
+            .select({ id: agents.id })
+            .from(agents)
+            .where(eq(agents.projectId, id));
+        const agentIds = projectAgents.map((a) => a.id);
+        const projectDocs = await this.db
+            .select({ id: documents.id })
+            .from(documents)
+            .where(eq(documents.projectId, id));
+        const docIds = projectDocs.map((d) => d.id);
+        const projectPrompts = await this.db
+            .select({ id: prompts.id })
+            .from(prompts)
+            .where(eq(prompts.projectId, id));
+        const promptIds = projectPrompts.map((p) => p.id);
+        const projectProfiles = await this.db
+            .select({ id: agentProfiles.id })
+            .from(agentProfiles)
+            .where(eq(agentProfiles.projectId, id));
+        const profileIds = projectProfiles.map((p) => p.id);
+        const projectTags = await this.db
+            .select({ id: tags.id })
+            .from(tags)
+            .where(eq(tags.projectId, id));
+        const tagIds = projectTags.map((t) => t.id);
+        const projectSessions = agentIds.length > 0
+            ? await this.db
+                .select({ id: sessions.id })
+                .from(sessions)
+                .where(inArray(sessions.agentId, agentIds))
+            : [];
+        const sessionIds = projectSessions.map((s) => s.id);
+        if (messageIds.length > 0) {
+            await this.db.delete(chatMessageReads).where(inArray(chatMessageReads.messageId, messageIds));
+            await this.db
+                .delete(chatMessageTargets)
+                .where(inArray(chatMessageTargets.messageId, messageIds));
+            await this.db
+                .delete(chatThreadSessionInvites)
+                .where(inArray(chatThreadSessionInvites.inviteMessageId, messageIds));
+        }
+        if (agentIds.length > 0) {
+            await this.db.delete(chatMessageReads).where(inArray(chatMessageReads.agentId, agentIds));
+            await this.db.delete(chatMessageTargets).where(inArray(chatMessageTargets.agentId, agentIds));
+            await this.db
+                .delete(chatThreadSessionInvites)
+                .where(inArray(chatThreadSessionInvites.agentId, agentIds));
+            await this.db.delete(chatActivities).where(inArray(chatActivities.agentId, agentIds));
+            await this.db.delete(chatMembers).where(inArray(chatMembers.agentId, agentIds));
+        }
+        if (messageIds.length > 0) {
+            await this.db.delete(chatMessages).where(inArray(chatMessages.threadId, threadIds));
+        }
+        if (threadIds.length > 0) {
+            await this.db.delete(chatThreads).where(inArray(chatThreads.id, threadIds));
+        }
+        if (sessionIds.length > 0) {
+            await this.db.delete(transcripts).where(inArray(transcripts.sessionId, sessionIds));
+            await this.db.delete(sessions).where(inArray(sessions.id, sessionIds));
+        }
+        if (epicIds.length > 0) {
+            await this.db.delete(epicComments).where(inArray(epicComments.epicId, epicIds));
+            const projectRecords = await this.db
+                .select({ id: records.id })
+                .from(records)
+                .where(inArray(records.epicId, epicIds));
+            const recordIds = projectRecords.map((r) => r.id);
+            if (recordIds.length > 0) {
+                await this.db.delete(recordTags).where(inArray(recordTags.recordId, recordIds));
+                await this.db.delete(records).where(inArray(records.id, recordIds));
+            }
+            await this.db.delete(epicTags).where(inArray(epicTags.epicId, epicIds));
+        }
+        if (epicIds.length > 0) {
+            await this.db.delete(epics).where(inArray(epics.id, epicIds));
+        }
+        if (docIds.length > 0) {
+            await this.db.delete(documentTags).where(inArray(documentTags.documentId, docIds));
+            await this.db.delete(documents).where(inArray(documents.id, docIds));
+        }
+        if (promptIds.length > 0) {
+            await this.db.delete(promptTags).where(inArray(promptTags.promptId, promptIds));
+            await this.db
+                .delete(agentProfilePrompts)
+                .where(inArray(agentProfilePrompts.promptId, promptIds));
+            await this.db.delete(prompts).where(inArray(prompts.id, promptIds));
+        }
+        if (agentIds.length > 0) {
+            await this.db.delete(agents).where(inArray(agents.id, agentIds));
+        }
+        if (profileIds.length > 0) {
+            await this.db
+                .delete(agentProfilePrompts)
+                .where(inArray(agentProfilePrompts.profileId, profileIds));
+            await this.db.delete(agentProfiles).where(inArray(agentProfiles.id, profileIds));
+        }
+        if (tagIds.length > 0) {
+            await this.db.delete(tags).where(inArray(tags.id, tagIds));
+        }
+        await this.db.delete(statuses).where(eq(statuses.projectId, id));
+        await this.db.delete(guests).where(eq(guests.projectId, id));
+        await this.db.delete(projects).where(eq(projects.id, id));
+        logger.info({ projectId: id }, 'Deleted project and all related records');
+    }
+}
+exports.ProjectStorageDelegate = ProjectStorageDelegate;
+//# sourceMappingURL=project.delegate.js.map