devchain-cli 0.9.0 → 0.9.2

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

@@ -54,6 +54,14 @@ const logger_1 = require("../../../common/logging/logger");
 const sqlite_raw_1 = require("../db/sqlite-raw");
 const feature_flags_1 = require("../../../common/config/feature-flags");
 const logger = (0, logger_1.createLogger)('LocalStorageService');
+const COMMUNITY_SOURCE_NAME_PATTERN = /^[a-z0-9-]+$/;
+const RESERVED_COMMUNITY_SOURCE_NAMES = new Set([
+    'anthropic',
+    'openai',
+    'microsoft',
+    'trailofbits',
+    'vercel',
+]);
 let LocalStorageService = class LocalStorageService {
     constructor(db) {
         this.db = db;
@@ -121,6 +129,97 @@ let LocalStorageService = class LocalStorageService {
         }
         return JSON.stringify(skillsRequired);
     }
+    normalizeCommunitySourceName(name) {
+        const normalized = name.trim().toLowerCase();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('name is required.', { fieldName: 'name' });
+        }
+        if (!COMMUNITY_SOURCE_NAME_PATTERN.test(normalized)) {
+            throw new error_types_1.ValidationError('Invalid community source name. Use lowercase letters, numbers, and hyphens only.', { name: normalized });
+        }
+        if (RESERVED_COMMUNITY_SOURCE_NAMES.has(normalized)) {
+            throw new error_types_1.ValidationError('Community source name conflicts with a built-in source.', {
+                name: normalized,
+            });
+        }
+        return normalized;
+    }
+    normalizeCommunitySourceNameForLookup(name) {
+        const normalized = name.trim().toLowerCase();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('name is required.', { fieldName: 'name' });
+        }
+        if (!COMMUNITY_SOURCE_NAME_PATTERN.test(normalized)) {
+            throw new error_types_1.ValidationError('Invalid community source name. Use lowercase letters, numbers, and hyphens only.', { name: normalized });
+        }
+        return normalized;
+    }
+    normalizeCommunityRepoPart(value, fieldName) {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized) {
+            throw new error_types_1.ValidationError(`${fieldName} is required.`, { fieldName });
+        }
+        return normalized;
+    }
+    normalizeCommunityBranch(branch) {
+        const normalized = (branch ?? 'main').trim();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('branch is required.', { fieldName: 'branch' });
+        }
+        return normalized;
+    }
+    normalizeLocalSkillSourceFolderPath(folderPath) {
+        const normalized = folderPath.trim();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('folderPath is required.', { fieldName: 'folderPath' });
+        }
+        return normalized;
+    }
+    async assertLocalSourceNameAvailableAcrossTypes(sourceName) {
+        if (RESERVED_COMMUNITY_SOURCE_NAMES.has(sourceName)) {
+            throw new error_types_1.ValidationError('Local source name conflicts with a built-in source.', {
+                name: sourceName,
+            });
+        }
+        const { communitySkillSources } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const existingCommunitySource = await this.db
+            .select({ id: communitySkillSources.id })
+            .from(communitySkillSources)
+            .where(eq(communitySkillSources.name, sourceName))
+            .limit(1);
+        if (existingCommunitySource.length > 0) {
+            throw new error_types_1.ConflictError('Local source name conflicts with an existing community source.', {
+                name: sourceName,
+            });
+        }
+    }
+    normalizeProjectIdForSourceEnablement(projectId) {
+        const normalized = projectId.trim();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('projectId is required.', { fieldName: 'projectId' });
+        }
+        return normalized;
+    }
+    normalizeSourceNameForSourceEnablement(sourceName) {
+        const normalized = sourceName.trim().toLowerCase();
+        if (!normalized) {
+            throw new error_types_1.ValidationError('sourceName is required.', { fieldName: 'sourceName' });
+        }
+        return normalized;
+    }
+    isSqliteUniqueConstraint(error) {
+        if (typeof error !== 'object' || error === null) {
+            return false;
+        }
+        const code = 'code' in error ? error.code : undefined;
+        const message = 'message' in error ? error.message : undefined;
+        const normalizedMessage = typeof message === 'string' ? message : '';
+        return (code === 'SQLITE_CONSTRAINT' ||
+            code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+            code === 19 ||
+            normalizedMessage.includes('UNIQUE constraint failed'));
+    }
     async ensureValidEpicParent(projectId, parentId, childId) {
         if (!parentId) {
             return;
@@ -187,6 +286,39 @@ let LocalStorageService = class LocalStorageService {
             });
         }
     }
+    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 = (0, sqlite_raw_1.getRawSqliteClient)(this.db);
+        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();
@@ -197,7 +329,8 @@ let LocalStorageService = class LocalStorageService {
             createdAt: now,
             updatedAt: now,
         };
-        const { projects, statuses } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        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,
@@ -226,6 +359,15 @@ let LocalStorageService = class LocalStorageService {
                     updatedAt: now,
                 });
             }
+            if (seedableSourceNames.length > 0) {
+                await tx.insert(sourceProjectEnabled).values(seedableSourceNames.map((sourceName) => ({
+                    id: randomUUID(),
+                    projectId: project.id,
+                    sourceName,
+                    enabled: false,
+                    createdAt: now,
+                })));
+            }
         });
         logger.info({ projectId: project.id }, 'Created project with default statuses (transactional)');
         return project;
@@ -240,7 +382,8 @@ let LocalStorageService = class LocalStorageService {
             createdAt: now,
             updatedAt: now,
         };
-        const { projects, statuses, prompts, agentProfiles, agents, tags, promptTags, profileProviderConfigs, providers, } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        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 = {};
@@ -277,6 +420,15 @@ let LocalStorageService = class LocalStorageService {
                 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: false,
+                    createdAt: now,
+                })));
+            }
             const { eq, and, or, isNull } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
             for (const p of template.prompts) {
                 const promptId = randomUUID();
@@ -1901,6 +2053,304 @@ let LocalStorageService = class LocalStorageService {
         }
         return this.updateProvider(id, update);
     }
+    async getSourceProjectEnabled(projectId, sourceName) {
+        const normalizedProjectId = this.normalizeProjectIdForSourceEnablement(projectId);
+        const normalizedSourceName = this.normalizeSourceNameForSourceEnablement(sourceName);
+        const { sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({ enabled: sourceProjectEnabled.enabled })
+            .from(sourceProjectEnabled)
+            .where(and(eq(sourceProjectEnabled.projectId, normalizedProjectId), eq(sourceProjectEnabled.sourceName, normalizedSourceName)))
+            .limit(1);
+        return rows[0] ? Boolean(rows[0].enabled) : null;
+    }
+    async setSourceProjectEnabled(projectId, sourceName, enabled) {
+        const normalizedProjectId = this.normalizeProjectIdForSourceEnablement(projectId);
+        const normalizedSourceName = this.normalizeSourceNameForSourceEnablement(sourceName);
+        const { sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { and, eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const existing = await this.db
+            .select({ id: sourceProjectEnabled.id })
+            .from(sourceProjectEnabled)
+            .where(and(eq(sourceProjectEnabled.projectId, normalizedProjectId), eq(sourceProjectEnabled.sourceName, normalizedSourceName)))
+            .limit(1);
+        if (existing[0]) {
+            await this.db
+                .update(sourceProjectEnabled)
+                .set({ enabled })
+                .where(eq(sourceProjectEnabled.id, existing[0].id));
+            return;
+        }
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        await this.db.insert(sourceProjectEnabled).values({
+            id: randomUUID(),
+            projectId: normalizedProjectId,
+            sourceName: normalizedSourceName,
+            enabled,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async listSourceProjectEnabled(projectId) {
+        const normalizedProjectId = this.normalizeProjectIdForSourceEnablement(projectId);
+        const { sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { asc, eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select({
+            sourceName: sourceProjectEnabled.sourceName,
+            enabled: sourceProjectEnabled.enabled,
+        })
+            .from(sourceProjectEnabled)
+            .where(eq(sourceProjectEnabled.projectId, normalizedProjectId))
+            .orderBy(asc(sourceProjectEnabled.sourceName));
+        return rows.map((row) => ({
+            sourceName: row.sourceName,
+            enabled: Boolean(row.enabled),
+        }));
+    }
+    async seedSourceProjectDisabled(projectId, sourceNames) {
+        const normalizedProjectId = this.normalizeProjectIdForSourceEnablement(projectId);
+        const normalizedSourceNames = [
+            ...new Set(sourceNames.map((name) => name.trim().toLowerCase())),
+        ].filter((name) => name.length > 0);
+        if (normalizedSourceNames.length === 0) {
+            return;
+        }
+        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 { sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+            const { and, eq, inArray } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            const existingRows = await this.db
+                .select({ sourceName: sourceProjectEnabled.sourceName })
+                .from(sourceProjectEnabled)
+                .where(and(eq(sourceProjectEnabled.projectId, normalizedProjectId), inArray(sourceProjectEnabled.sourceName, normalizedSourceNames)));
+            const existingSourceNames = new Set(existingRows.map((row) => row.sourceName));
+            const sourceNamesToInsert = normalizedSourceNames.filter((sourceName) => !existingSourceNames.has(sourceName));
+            if (sourceNamesToInsert.length > 0) {
+                const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+                const now = new Date().toISOString();
+                await this.db.insert(sourceProjectEnabled).values(sourceNamesToInsert.map((sourceName) => ({
+                    id: randomUUID(),
+                    projectId: normalizedProjectId,
+                    sourceName,
+                    enabled: false,
+                    createdAt: now,
+                })));
+            }
+            sqlite.exec('COMMIT');
+        }
+        catch (error) {
+            try {
+                sqlite.exec('ROLLBACK');
+            }
+            catch (rollbackError) {
+                logger.error({ rollbackError }, 'Failed to rollback seedSourceProjectDisabled transaction');
+            }
+            throw error;
+        }
+    }
+    async deleteSourceProjectEnabledBySource(sourceName) {
+        const normalizedSourceName = this.normalizeSourceNameForSourceEnablement(sourceName);
+        const { sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db
+            .delete(sourceProjectEnabled)
+            .where(eq(sourceProjectEnabled.sourceName, normalizedSourceName));
+    }
+    async listCommunitySkillSources() {
+        const { communitySkillSources } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(communitySkillSources)
+            .orderBy(asc(communitySkillSources.name));
+        return rows;
+    }
+    async getCommunitySkillSource(id) {
+        const normalizedId = id.trim();
+        if (!normalizedId) {
+            throw new error_types_1.ValidationError('id is required.', { fieldName: 'id' });
+        }
+        const { communitySkillSources } = 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(communitySkillSources)
+            .where(eq(communitySkillSources.id, normalizedId))
+            .limit(1);
+        if (!rows[0]) {
+            throw new error_types_1.NotFoundError('Community skill source', normalizedId);
+        }
+        return rows[0];
+    }
+    async getCommunitySkillSourceByName(name) {
+        const normalizedName = this.normalizeCommunitySourceNameForLookup(name);
+        const { communitySkillSources } = 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(communitySkillSources)
+            .where(eq(communitySkillSources.name, normalizedName))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async createCommunitySkillSource(data) {
+        const normalizedName = this.normalizeCommunitySourceName(data.name);
+        const normalizedRepoOwner = this.normalizeCommunityRepoPart(data.repoOwner, 'repoOwner');
+        const normalizedRepoName = this.normalizeCommunityRepoPart(data.repoName, 'repoName');
+        const normalizedBranch = this.normalizeCommunityBranch(data.branch);
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const record = {
+            id: randomUUID(),
+            name: normalizedName,
+            repoOwner: normalizedRepoOwner,
+            repoName: normalizedRepoName,
+            branch: normalizedBranch,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const { communitySkillSources } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        try {
+            await this.db.insert(communitySkillSources).values({
+                id: record.id,
+                name: record.name,
+                repoOwner: record.repoOwner,
+                repoName: record.repoName,
+                branch: record.branch,
+                createdAt: record.createdAt,
+                updatedAt: record.updatedAt,
+            });
+        }
+        catch (error) {
+            if (this.isSqliteUniqueConstraint(error)) {
+                const rawMessage = typeof error === 'object' && error !== null && 'message' in error
+                    ? String(error.message ?? '')
+                    : '';
+                if (rawMessage.includes('community_skill_sources.name')) {
+                    throw new error_types_1.ConflictError('Community skill source name already exists.', {
+                        name: normalizedName,
+                    });
+                }
+                throw new error_types_1.ConflictError('Community skill source repository already exists.', {
+                    repoOwner: normalizedRepoOwner,
+                    repoName: normalizedRepoName,
+                });
+            }
+            throw new error_types_1.StorageError('Failed to create community skill source.', {
+                name: normalizedName,
+                repoOwner: normalizedRepoOwner,
+                repoName: normalizedRepoName,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+        logger.info({ communitySkillSourceId: record.id, name: record.name }, 'Created community skill source');
+        return record;
+    }
+    async deleteCommunitySkillSource(id) {
+        const source = await this.getCommunitySkillSource(id);
+        const { communitySkillSources, skills, sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.transaction(async (tx) => {
+            await tx.delete(skills).where(eq(skills.source, source.name));
+            await tx.delete(sourceProjectEnabled).where(eq(sourceProjectEnabled.sourceName, source.name));
+            await tx.delete(communitySkillSources).where(eq(communitySkillSources.id, source.id));
+        });
+        logger.info({ communitySkillSourceId: source.id, sourceName: source.name }, 'Deleted community skill source and related skills');
+    }
+    async listLocalSkillSources() {
+        const { localSkillSources } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { asc } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        const rows = await this.db
+            .select()
+            .from(localSkillSources)
+            .orderBy(asc(localSkillSources.name));
+        return rows;
+    }
+    async getLocalSkillSource(id) {
+        const normalizedId = id.trim();
+        if (!normalizedId) {
+            throw new error_types_1.ValidationError('id is required.', { fieldName: 'id' });
+        }
+        const { localSkillSources } = 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(localSkillSources)
+            .where(eq(localSkillSources.id, normalizedId))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async createLocalSkillSource(data) {
+        const normalizedName = this.normalizeCommunitySourceNameForLookup(data.name);
+        const normalizedFolderPath = this.normalizeLocalSkillSourceFolderPath(data.folderPath);
+        await this.assertLocalSourceNameAvailableAcrossTypes(normalizedName);
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const now = new Date().toISOString();
+        const record = {
+            id: randomUUID(),
+            name: normalizedName,
+            folderPath: normalizedFolderPath,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const { localSkillSources } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        try {
+            await this.db.insert(localSkillSources).values({
+                id: record.id,
+                name: record.name,
+                folderPath: record.folderPath,
+                createdAt: record.createdAt,
+                updatedAt: record.updatedAt,
+            });
+        }
+        catch (error) {
+            if (this.isSqliteUniqueConstraint(error)) {
+                const rawMessage = typeof error === 'object' && error !== null && 'message' in error
+                    ? String(error.message ?? '')
+                    : '';
+                if (rawMessage.includes('local_skill_sources.name')) {
+                    throw new error_types_1.ConflictError('Local skill source name already exists.', {
+                        name: normalizedName,
+                    });
+                }
+                if (rawMessage.includes('local_skill_sources.folder_path')) {
+                    throw new error_types_1.ConflictError('Local skill source folder path already exists.', {
+                        folderPath: normalizedFolderPath,
+                    });
+                }
+                throw new error_types_1.ConflictError('Local skill source already exists.', {
+                    name: normalizedName,
+                    folderPath: normalizedFolderPath,
+                });
+            }
+            throw new error_types_1.StorageError('Failed to create local skill source.', {
+                name: normalizedName,
+                folderPath: normalizedFolderPath,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+        logger.info({ localSkillSourceId: record.id, name: record.name }, 'Created local skill source');
+        return record;
+    }
+    async deleteLocalSkillSource(id) {
+        const source = await this.getLocalSkillSource(id);
+        if (!source) {
+            throw new error_types_1.NotFoundError('Local skill source', id.trim());
+        }
+        const { localSkillSources, skills, sourceProjectEnabled } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const { eq } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+        await this.db.transaction(async (tx) => {
+            await tx.delete(skills).where(eq(skills.source, source.name));
+            await tx.delete(sourceProjectEnabled).where(eq(sourceProjectEnabled.sourceName, source.name));
+            await tx.delete(localSkillSources).where(eq(localSkillSources.id, source.id));
+        });
+        logger.info({ localSkillSourceId: source.id, sourceName: source.name }, 'Deleted local skill source and related skills');
+    }
     async createAgentProfile(data) {
         const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
         const now = new Date().toISOString();