devchain-cli 0.9.1 → 0.10.0

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

@@ -168,6 +168,46 @@ let LocalStorageService = class LocalStorageService {
         }
         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;
@@ -246,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();
@@ -256,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,
@@ -285,21 +359,32 @@ 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;
     }
-    async createProjectWithTemplate(data, template) {
+    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: randomUUID(),
+            id: providedProjectId || randomUUID(),
             ...data,
             isTemplate: data.isTemplate ?? false,
             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 = {};
@@ -336,6 +421,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();
@@ -483,6 +577,15 @@ let LocalStorageService = class LocalStorageService {
                 logger.error({ rollbackError }, 'Failed to rollback transaction');
             }
             logger.error({ error, projectId: project.id }, 'Transaction failed');
+            const errorMessage = error instanceof Error ? error.message : '';
+            if (providedProjectId &&
+                this.isSqliteUniqueConstraint(error) &&
+                errorMessage.includes('projects.id')) {
+                throw new error_types_1.ConflictError(`Project ID "${providedProjectId}" already exists.`, {
+                    field: 'projectId',
+                    projectId: providedProjectId,
+                });
+            }
             throw error;
         }
         return {
@@ -1868,6 +1971,11 @@ let LocalStorageService = class LocalStorageService {
         const { randomUUID } = await Promise.resolve().then(() => __importStar(require('crypto')));
         const now = new Date().toISOString();
         const { providers } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        const autoCompactThreshold = data.autoCompactThreshold !== undefined
+            ? data.autoCompactThreshold
+            : data.name.toLowerCase() === 'claude'
+                ? 10
+                : null;
         const provider = {
             id: randomUUID(),
             name: data.name,
@@ -1875,6 +1983,7 @@ let LocalStorageService = class LocalStorageService {
             mcpConfigured: data.mcpConfigured ?? false,
             mcpEndpoint: data.mcpEndpoint ?? null,
             mcpRegisteredAt: data.mcpRegisteredAt ?? null,
+            autoCompactThreshold,
             createdAt: now,
             updatedAt: now,
         };
@@ -1885,6 +1994,7 @@ let LocalStorageService = class LocalStorageService {
             mcpConfigured: provider.mcpConfigured,
             mcpEndpoint: provider.mcpEndpoint,
             mcpRegisteredAt: provider.mcpRegisteredAt,
+            autoCompactThreshold: provider.autoCompactThreshold,
             createdAt: provider.createdAt,
             updatedAt: provider.updatedAt,
         });
@@ -1960,6 +2070,114 @@ 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')));
@@ -2052,14 +2270,104 @@ let LocalStorageService = class LocalStorageService {
     }
     async deleteCommunitySkillSource(id) {
         const source = await this.getCommunitySkillSource(id);
-        const { communitySkillSources, skills } = await Promise.resolve().then(() => __importStar(require('../db/schema')));
+        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();