devchain-cli 0.8.5 → 0.9.1

package/dist/server/modules/skills/services/skills.service.js

@@ -0,0 +1,734 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsService = void 0;
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const drizzle_orm_1 = require("drizzle-orm");
+const error_types_1 = require("../../../common/errors/error-types");
+const logger_1 = require("../../../common/logging/logger");
+const settings_service_1 = require("../../settings/services/settings.service");
+const db_provider_1 = require("../../storage/db/db.provider");
+const schema_1 = require("../../storage/db/schema");
+const skill_source_registry_service_1 = require("./skill-source-registry.service");
+const logger = (0, logger_1.createLogger)('SkillsService');
+const VALID_SKILL_STATUSES = ['available', 'outdated', 'sync_error'];
+let SkillsService = class SkillsService {
+    constructor(db, settingsService, skillSourceRegistry) {
+        this.db = db;
+        this.settingsService = settingsService;
+        this.skillSourceRegistry = skillSourceRegistry;
+    }
+    async listSkills(options = {}) {
+        const enabledSources = await this.getEnabledSources();
+        if (enabledSources.length === 0) {
+            return [];
+        }
+        const conditions = [];
+        conditions.push((0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources));
+        if (options.source) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skills.source, options.source.trim().toLowerCase()));
+        }
+        if (options.category) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skills.category, options.category));
+        }
+        if (options.status) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skills.status, options.status));
+        }
+        const searchTerm = options.q?.trim().toLowerCase();
+        if (searchTerm) {
+            const likePattern = `%${searchTerm}%`;
+            conditions.push((0, drizzle_orm_1.sql) `(
+          lower(${schema_1.skills.slug}) LIKE ${likePattern}
+          OR lower(${schema_1.skills.name}) LIKE ${likePattern}
+          OR lower(${schema_1.skills.displayName}) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.description}, '')) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.shortDescription}, '')) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.compatibility}, '')) LIKE ${likePattern}
+        )`);
+        }
+        const whereClause = this.combineConditions(conditions);
+        const query = this.db.select().from(schema_1.skills);
+        if (whereClause) {
+            query.where(whereClause);
+        }
+        const rows = await query.orderBy((0, drizzle_orm_1.asc)(schema_1.skills.name), (0, drizzle_orm_1.asc)(schema_1.skills.slug));
+        return rows.map((row) => this.mapSkillRow(row));
+    }
+    async listAllForProject(projectId, options = {}) {
+        const enabledSources = await this.getEnabledSources();
+        if (enabledSources.length === 0) {
+            return [];
+        }
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const query = this.db
+            .select({
+            skill: schema_1.skills,
+            disabled: (0, drizzle_orm_1.sql) `case when ${schema_1.skillProjectDisabled.id} is null then 0 else 1 end`,
+        })
+            .from(schema_1.skills)
+            .leftJoin(schema_1.skillProjectDisabled, (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.skillId, schema_1.skills.id), (0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId)));
+        const conditions = [(0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources)];
+        this.appendProjectSkillFilterConditions(conditions, options);
+        const whereClause = this.combineConditions(conditions);
+        if (whereClause) {
+            query.where(whereClause);
+        }
+        const rows = await query.orderBy((0, drizzle_orm_1.asc)(schema_1.skills.name), (0, drizzle_orm_1.asc)(schema_1.skills.slug));
+        return rows.map((row) => ({
+            ...this.mapSkillRow(row.skill),
+            disabled: Number(row.disabled) === 1,
+        }));
+    }
+    async listDiscoverable(projectId, options = {}) {
+        const enabledSources = await this.getEnabledSources();
+        if (enabledSources.length === 0) {
+            return [];
+        }
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const query = this.db
+            .select({ skill: schema_1.skills })
+            .from(schema_1.skills)
+            .leftJoin(schema_1.skillProjectDisabled, (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.skillId, schema_1.skills.id), (0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId)));
+        const conditions = [(0, drizzle_orm_1.isNull)(schema_1.skillProjectDisabled.id)];
+        conditions.push((0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources));
+        this.appendProjectSkillFilterConditions(conditions, options);
+        const whereClause = this.combineConditions(conditions);
+        if (whereClause) {
+            query.where(whereClause);
+        }
+        const rows = await query.orderBy((0, drizzle_orm_1.asc)(schema_1.skills.name), (0, drizzle_orm_1.asc)(schema_1.skills.slug));
+        return rows.map((row) => this.mapSkillRow(row.skill));
+    }
+    async getSkill(id) {
+        const skillId = this.requireNonEmpty(id, 'id');
+        const row = await this.db.select().from(schema_1.skills).where((0, drizzle_orm_1.eq)(schema_1.skills.id, skillId)).limit(1);
+        if (!row[0]) {
+            throw new error_types_1.NotFoundError('Skill', skillId);
+        }
+        return this.mapSkillRow(row[0]);
+    }
+    async getSkillBySlug(slug) {
+        const normalizedSlug = this.requireNonEmpty(slug, 'slug');
+        const row = await this.db.select().from(schema_1.skills).where((0, drizzle_orm_1.eq)(schema_1.skills.slug, normalizedSlug)).limit(1);
+        if (!row[0]) {
+            throw new error_types_1.NotFoundError('Skill', normalizedSlug);
+        }
+        return this.mapSkillRow(row[0]);
+    }
+    async resolveSkillSummariesBySlugs(slugsToResolve) {
+        const uniqueSlugs = Array.from(new Set(slugsToResolve.map((slug) => this.requireNonEmpty(slug, 'slug').toLowerCase())));
+        if (uniqueSlugs.length === 0) {
+            return {};
+        }
+        const rows = await this.db
+            .select({
+            id: schema_1.skills.id,
+            slug: schema_1.skills.slug,
+            name: schema_1.skills.name,
+            displayName: schema_1.skills.displayName,
+            source: schema_1.skills.source,
+            category: schema_1.skills.category,
+            shortDescription: schema_1.skills.shortDescription,
+            description: schema_1.skills.description,
+        })
+            .from(schema_1.skills)
+            .where((0, drizzle_orm_1.inArray)(schema_1.skills.slug, uniqueSlugs));
+        const resolved = {};
+        for (const row of rows) {
+            resolved[row.slug] = {
+                id: row.id,
+                slug: row.slug,
+                name: row.name,
+                displayName: row.displayName,
+                source: row.source,
+                category: row.category,
+                shortDescription: row.shortDescription,
+                description: row.description,
+            };
+        }
+        return resolved;
+    }
+    async upsertSkill(slug, data) {
+        const normalizedSlug = this.requireNonEmpty(slug, 'slug');
+        const now = new Date().toISOString();
+        const existing = await this.db
+            .select()
+            .from(schema_1.skills)
+            .where((0, drizzle_orm_1.eq)(schema_1.skills.slug, normalizedSlug))
+            .limit(1);
+        if (existing[0]) {
+            const updatePayload = { updatedAt: now };
+            if (data.name !== undefined) {
+                updatePayload.name = this.requireNonEmpty(data.name, 'name');
+            }
+            if (data.displayName !== undefined) {
+                updatePayload.displayName = this.requireNonEmpty(data.displayName, 'displayName');
+            }
+            if (data.source !== undefined) {
+                updatePayload.source = this.requireNonEmpty(data.source, 'source');
+            }
+            if (data.description !== undefined) {
+                updatePayload.description = this.normalizeNullableString(data.description);
+            }
+            if (data.shortDescription !== undefined) {
+                updatePayload.shortDescription = this.normalizeNullableString(data.shortDescription);
+            }
+            if (data.sourceUrl !== undefined) {
+                updatePayload.sourceUrl = this.normalizeNullableString(data.sourceUrl);
+            }
+            if (data.sourceCommit !== undefined) {
+                updatePayload.sourceCommit = this.normalizeNullableString(data.sourceCommit);
+            }
+            if (data.category !== undefined) {
+                updatePayload.category = this.normalizeNullableString(data.category);
+            }
+            if (data.license !== undefined) {
+                updatePayload.license = this.normalizeNullableString(data.license);
+            }
+            if (data.compatibility !== undefined) {
+                updatePayload.compatibility = this.normalizeNullableString(data.compatibility);
+            }
+            if (data.instructionContent !== undefined) {
+                updatePayload.instructionContent = this.normalizeNullableString(data.instructionContent);
+            }
+            if (data.contentPath !== undefined) {
+                updatePayload.contentPath = this.normalizeNullableString(data.contentPath);
+            }
+            if (data.lastSyncedAt !== undefined) {
+                updatePayload.lastSyncedAt = this.normalizeNullableString(data.lastSyncedAt);
+            }
+            if (data.frontmatter !== undefined) {
+                updatePayload.frontmatter = this.serializeJsonObject(data.frontmatter, 'frontmatter');
+            }
+            if (data.resources !== undefined) {
+                updatePayload.resources = this.serializeResources(data.resources);
+            }
+            if (data.status !== undefined) {
+                updatePayload.status = this.validateStatus(data.status);
+            }
+            await this.db.update(schema_1.skills).set(updatePayload).where((0, drizzle_orm_1.eq)(schema_1.skills.slug, normalizedSlug));
+            return this.getSkillBySlug(normalizedSlug);
+        }
+        const source = this.requireNonEmpty(data.source ?? '', 'source');
+        const name = this.requireNonEmpty(data.name ?? normalizedSlug, 'name');
+        const displayName = this.requireNonEmpty(data.displayName ?? data.name ?? normalizedSlug, 'displayName');
+        const insertPayload = {
+            id: (0, node_crypto_1.randomUUID)(),
+            slug: normalizedSlug,
+            name,
+            displayName,
+            description: this.normalizeNullableString(data.description ?? null),
+            shortDescription: this.normalizeNullableString(data.shortDescription ?? null),
+            source,
+            sourceUrl: this.normalizeNullableString(data.sourceUrl ?? null),
+            sourceCommit: this.normalizeNullableString(data.sourceCommit ?? null),
+            category: this.normalizeNullableString(data.category ?? null),
+            license: this.normalizeNullableString(data.license ?? null),
+            compatibility: this.normalizeNullableString(data.compatibility ?? null),
+            frontmatter: this.serializeJsonObject(data.frontmatter ?? null, 'frontmatter'),
+            instructionContent: this.normalizeNullableString(data.instructionContent ?? null),
+            contentPath: this.normalizeNullableString(data.contentPath ?? null),
+            resources: this.serializeResources(data.resources ?? []),
+            status: this.validateStatus(data.status ?? 'available'),
+            lastSyncedAt: this.normalizeNullableString(data.lastSyncedAt ?? null),
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.db.insert(schema_1.skills).values(insertPayload);
+        return this.getSkillBySlug(normalizedSlug);
+    }
+    async disableSkill(projectId, skillId) {
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const normalizedSkillId = this.requireNonEmpty(skillId, 'skillId');
+        const now = new Date().toISOString();
+        try {
+            await this.db.insert(schema_1.skillProjectDisabled).values({
+                id: (0, node_crypto_1.randomUUID)(),
+                projectId: normalizedProjectId,
+                skillId: normalizedSkillId,
+                createdAt: now,
+            });
+        }
+        catch (error) {
+            if (this.isUniqueConstraintError(error)) {
+                return;
+            }
+            if (this.isForeignKeyConstraintError(error)) {
+                throw new error_types_1.ValidationError('Cannot disable skill for unknown project or skill.', {
+                    projectId: normalizedProjectId,
+                    skillId: normalizedSkillId,
+                });
+            }
+            throw new error_types_1.StorageError('Failed to disable skill for project.', {
+                projectId: normalizedProjectId,
+                skillId: normalizedSkillId,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async enableSkill(projectId, skillId) {
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const normalizedSkillId = this.requireNonEmpty(skillId, 'skillId');
+        await this.db
+            .delete(schema_1.skillProjectDisabled)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId), (0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.skillId, normalizedSkillId)));
+    }
+    async listDisabled(projectId) {
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const rows = await this.db
+            .select({ skillId: schema_1.skillProjectDisabled.skillId })
+            .from(schema_1.skillProjectDisabled)
+            .where((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId))
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.skillProjectDisabled.createdAt));
+        return rows.map((row) => row.skillId);
+    }
+    async disableAll(projectId) {
+        const enabledSources = await this.getEnabledSources();
+        if (enabledSources.length === 0) {
+            return 0;
+        }
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const now = new Date().toISOString();
+        const [allSkills, disabledRows] = await Promise.all([
+            this.db
+                .select({ skillId: schema_1.skills.id })
+                .from(schema_1.skills)
+                .where((0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources)),
+            this.db
+                .select({ skillId: schema_1.skillProjectDisabled.skillId })
+                .from(schema_1.skillProjectDisabled)
+                .innerJoin(schema_1.skills, (0, drizzle_orm_1.eq)(schema_1.skills.id, schema_1.skillProjectDisabled.skillId))
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId), (0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources))),
+        ]);
+        const disabledSet = new Set(disabledRows.map((row) => row.skillId));
+        const rowsToInsert = allSkills
+            .filter((row) => !disabledSet.has(row.skillId))
+            .map((row) => ({
+            id: (0, node_crypto_1.randomUUID)(),
+            projectId: normalizedProjectId,
+            skillId: row.skillId,
+            createdAt: now,
+        }));
+        if (rowsToInsert.length === 0) {
+            return 0;
+        }
+        await this.db.insert(schema_1.skillProjectDisabled).values(rowsToInsert);
+        return rowsToInsert.length;
+    }
+    async enableAll(projectId) {
+        const enabledSources = await this.getEnabledSources();
+        if (enabledSources.length === 0) {
+            return 0;
+        }
+        const normalizedProjectId = this.requireNonEmpty(projectId, 'projectId');
+        const disabledRows = await this.db
+            .select({ skillId: schema_1.skillProjectDisabled.skillId })
+            .from(schema_1.skillProjectDisabled)
+            .innerJoin(schema_1.skills, (0, drizzle_orm_1.eq)(schema_1.skills.id, schema_1.skillProjectDisabled.skillId))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId), (0, drizzle_orm_1.inArray)(schema_1.skills.source, enabledSources)));
+        if (disabledRows.length === 0) {
+            return 0;
+        }
+        const disabledSkillIds = disabledRows.map((row) => row.skillId);
+        await this.db
+            .delete(schema_1.skillProjectDisabled)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.skillProjectDisabled.projectId, normalizedProjectId), (0, drizzle_orm_1.inArray)(schema_1.skillProjectDisabled.skillId, disabledSkillIds)));
+        return disabledRows.length;
+    }
+    async listSources() {
+        const sourceRows = await this.db
+            .select({ source: schema_1.skills.source, skillCount: (0, drizzle_orm_1.count)() })
+            .from(schema_1.skills)
+            .groupBy(schema_1.skills.source);
+        const sourceCountMap = new Map(sourceRows.map((row) => [row.source.trim().toLowerCase(), Number(row.skillCount)]));
+        const sourceSettings = this.settingsService.getSkillSourcesEnabled();
+        const registeredSources = await this.getRegisteredSources();
+        return registeredSources.map((source) => ({
+            name: source.name,
+            enabled: this.isSourceEnabled(source.name, sourceSettings),
+            repoUrl: source.repoUrl,
+            skillCount: sourceCountMap.get(source.name) ?? 0,
+        }));
+    }
+    async setSourceEnabled(sourceName, enabled) {
+        const normalizedSourceName = await this.requireKnownSourceName(sourceName);
+        await this.settingsService.setSkillSourceEnabled(normalizedSourceName, enabled);
+        return { name: normalizedSourceName, enabled };
+    }
+    async logUsage(skillId, skillSlug, projectId, agentId, agentNameSnapshot) {
+        const normalizedSkillId = this.requireNonEmpty(skillId, 'skillId');
+        const normalizedSkillSlug = this.requireNonEmpty(skillSlug, 'skillSlug');
+        const now = new Date().toISOString();
+        const usageRecord = {
+            id: (0, node_crypto_1.randomUUID)(),
+            skillId: normalizedSkillId,
+            skillSlug: normalizedSkillSlug,
+            projectId: this.normalizeNullableString(projectId ?? null) ?? null,
+            agentId: this.normalizeNullableString(agentId ?? null) ?? null,
+            agentNameSnapshot: this.normalizeNullableString(agentNameSnapshot ?? null) ?? null,
+            accessedAt: now,
+        };
+        await this.db.insert(schema_1.skillUsageLog).values({
+            id: usageRecord.id,
+            skillId: usageRecord.skillId,
+            skillSlug: usageRecord.skillSlug,
+            projectId: usageRecord.projectId,
+            agentId: usageRecord.agentId,
+            agentNameSnapshot: usageRecord.agentNameSnapshot,
+            accessedAt: usageRecord.accessedAt,
+        });
+        return usageRecord;
+    }
+    async getUsageStats(options = {}) {
+        const conditions = [];
+        if (options.projectId !== undefined) {
+            if (options.projectId === null) {
+                conditions.push((0, drizzle_orm_1.isNull)(schema_1.skillUsageLog.projectId));
+            }
+            else {
+                conditions.push((0, drizzle_orm_1.eq)(schema_1.skillUsageLog.projectId, options.projectId));
+            }
+        }
+        if (options.from) {
+            conditions.push((0, drizzle_orm_1.gte)(schema_1.skillUsageLog.accessedAt, options.from));
+        }
+        if (options.to) {
+            conditions.push((0, drizzle_orm_1.lte)(schema_1.skillUsageLog.accessedAt, options.to));
+        }
+        const usageCountExpr = (0, drizzle_orm_1.count)();
+        const firstAccessedExpr = (0, drizzle_orm_1.sql) `min(${schema_1.skillUsageLog.accessedAt})`;
+        const lastAccessedExpr = (0, drizzle_orm_1.sql) `max(${schema_1.skillUsageLog.accessedAt})`;
+        const whereClause = this.combineConditions(conditions);
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const query = this.db
+            .select({
+            skillId: schema_1.skillUsageLog.skillId,
+            skillSlug: schema_1.skillUsageLog.skillSlug,
+            usageCount: usageCountExpr,
+            firstAccessedAt: firstAccessedExpr,
+            lastAccessedAt: lastAccessedExpr,
+            skillName: schema_1.skills.name,
+            skillDisplayName: schema_1.skills.displayName,
+        })
+            .from(schema_1.skillUsageLog)
+            .leftJoin(schema_1.skills, (0, drizzle_orm_1.eq)(schema_1.skills.id, schema_1.skillUsageLog.skillId));
+        if (whereClause) {
+            query.where(whereClause);
+        }
+        const rows = await query
+            .groupBy(schema_1.skillUsageLog.skillId, schema_1.skillUsageLog.skillSlug, schema_1.skills.name, schema_1.skills.displayName)
+            .orderBy((0, drizzle_orm_1.desc)(usageCountExpr), (0, drizzle_orm_1.desc)(lastAccessedExpr))
+            .limit(limit)
+            .offset(offset);
+        return rows.map((row) => ({
+            skillId: row.skillId,
+            skillSlug: row.skillSlug,
+            usageCount: Number(row.usageCount ?? 0),
+            firstAccessedAt: row.firstAccessedAt,
+            lastAccessedAt: row.lastAccessedAt,
+            skillName: row.skillName ?? null,
+            skillDisplayName: row.skillDisplayName ?? null,
+        }));
+    }
+    async listUsageLog(options = {}) {
+        const conditions = [];
+        if (options.projectId) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skillUsageLog.projectId, options.projectId));
+        }
+        if (options.skillId) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skillUsageLog.skillId, options.skillId));
+        }
+        if (options.agentId) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skillUsageLog.agentId, options.agentId));
+        }
+        if (options.from) {
+            conditions.push((0, drizzle_orm_1.gte)(schema_1.skillUsageLog.accessedAt, options.from));
+        }
+        if (options.to) {
+            conditions.push((0, drizzle_orm_1.lte)(schema_1.skillUsageLog.accessedAt, options.to));
+        }
+        const whereClause = this.combineConditions(conditions);
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const itemsQuery = this.db.select().from(schema_1.skillUsageLog);
+        if (whereClause) {
+            itemsQuery.where(whereClause);
+        }
+        const rows = await itemsQuery
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.skillUsageLog.accessedAt))
+            .limit(limit)
+            .offset(offset);
+        const totalQuery = this.db.select({ count: (0, drizzle_orm_1.sql) `count(*)` }).from(schema_1.skillUsageLog);
+        if (whereClause) {
+            totalQuery.where(whereClause);
+        }
+        const totalResult = await totalQuery;
+        const total = Number(totalResult[0]?.count ?? 0);
+        return {
+            items: rows.map((row) => ({
+                id: row.id,
+                skillId: row.skillId,
+                skillSlug: row.skillSlug,
+                projectId: row.projectId,
+                agentId: row.agentId,
+                agentNameSnapshot: row.agentNameSnapshot,
+                accessedAt: row.accessedAt,
+            })),
+            total,
+            limit,
+            offset,
+        };
+    }
+    appendProjectSkillFilterConditions(conditions, options) {
+        const searchTerm = options.q?.trim().toLowerCase();
+        if (searchTerm) {
+            const likePattern = `%${searchTerm}%`;
+            conditions.push((0, drizzle_orm_1.sql) `(
+          lower(${schema_1.skills.slug}) LIKE ${likePattern}
+          OR lower(${schema_1.skills.name}) LIKE ${likePattern}
+          OR lower(${schema_1.skills.displayName}) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.description}, '')) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.shortDescription}, '')) LIKE ${likePattern}
+          OR lower(coalesce(${schema_1.skills.compatibility}, '')) LIKE ${likePattern}
+        )`);
+        }
+        if (options.source) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skills.source, options.source.trim().toLowerCase()));
+        }
+        if (options.category) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.skills.category, options.category));
+        }
+    }
+    mapSkillRow(row) {
+        return {
+            id: row.id,
+            slug: row.slug,
+            name: row.name,
+            displayName: row.displayName,
+            description: row.description,
+            shortDescription: row.shortDescription,
+            source: row.source,
+            sourceUrl: row.sourceUrl,
+            sourceCommit: row.sourceCommit,
+            category: row.category,
+            license: row.license,
+            compatibility: row.compatibility,
+            frontmatter: this.parseJsonObject(row.frontmatter, 'frontmatter'),
+            instructionContent: row.instructionContent,
+            contentPath: row.contentPath,
+            resources: this.parseResources(row.resources),
+            status: this.parseStatus(row.status),
+            lastSyncedAt: row.lastSyncedAt,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+    }
+    parseJsonObject(rawValue, fieldName) {
+        if (rawValue === null) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            logger.warn({ fieldName }, 'Expected JSON object but found different type');
+            return null;
+        }
+        catch (error) {
+            logger.warn({
+                fieldName,
+                error: error instanceof Error ? error.message : String(error),
+            }, 'Failed to parse JSON object field');
+            return null;
+        }
+    }
+    parseResources(rawValue) {
+        if (rawValue === null) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                logger.warn('Expected resources JSON array but found different type');
+                return [];
+            }
+            return parsed
+                .filter((item) => typeof item === 'string')
+                .map((item) => item.trim())
+                .filter((item) => item.length > 0);
+        }
+        catch (error) {
+            logger.warn({ error: error instanceof Error ? error.message : String(error) }, 'Failed to parse resources JSON field');
+            return [];
+        }
+    }
+    serializeJsonObject(value, fieldName) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        try {
+            return JSON.stringify(value);
+        }
+        catch (error) {
+            throw new error_types_1.ValidationError(`Invalid ${fieldName}: value is not serializable JSON.`, {
+                fieldName,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    serializeResources(resources) {
+        if (resources === undefined) {
+            return undefined;
+        }
+        if (resources === null) {
+            return null;
+        }
+        if (!Array.isArray(resources)) {
+            throw new error_types_1.ValidationError('Invalid resources: expected an array of strings.');
+        }
+        const normalizedResources = resources
+            .filter((item) => typeof item === 'string')
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        try {
+            return JSON.stringify(normalizedResources);
+        }
+        catch (error) {
+            throw new error_types_1.ValidationError('Invalid resources: value is not serializable JSON.', {
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    validateStatus(status) {
+        if (VALID_SKILL_STATUSES.includes(status)) {
+            return status;
+        }
+        throw new error_types_1.ValidationError('Invalid skill status value.', {
+            status,
+            supportedStatuses: VALID_SKILL_STATUSES,
+        });
+    }
+    parseStatus(status) {
+        if (VALID_SKILL_STATUSES.includes(status)) {
+            return status;
+        }
+        logger.warn({ status }, 'Unknown skill status in database; defaulting to available');
+        return 'available';
+    }
+    normalizeNullableString(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    requireNonEmpty(value, fieldName) {
+        const normalized = value.trim();
+        if (!normalized) {
+            throw new error_types_1.ValidationError(`${fieldName} is required.`, { fieldName });
+        }
+        return normalized;
+    }
+    combineConditions(conditions) {
+        if (conditions.length === 0) {
+            return undefined;
+        }
+        if (conditions.length === 1) {
+            return conditions[0];
+        }
+        return (0, drizzle_orm_1.and)(...conditions);
+    }
+    async getRegisteredSources() {
+        const adapters = await this.skillSourceRegistry.getAdapters();
+        const sourceMap = new Map();
+        for (const adapter of adapters) {
+            const normalizedName = adapter.sourceName.trim().toLowerCase();
+            if (!normalizedName || sourceMap.has(normalizedName)) {
+                continue;
+            }
+            sourceMap.set(normalizedName, adapter.repoUrl);
+        }
+        return Array.from(sourceMap.entries())
+            .map(([name, repoUrl]) => ({ name, repoUrl }))
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    async getEnabledSources() {
+        const sourceSettings = this.settingsService.getSkillSourcesEnabled();
+        const registeredSources = await this.getRegisteredSources();
+        return registeredSources
+            .map((source) => source.name)
+            .filter((sourceName) => this.isSourceEnabled(sourceName, sourceSettings));
+    }
+    isSourceEnabled(sourceName, sourceSettings) {
+        return sourceSettings[sourceName] !== false;
+    }
+    async requireKnownSourceName(sourceName) {
+        const normalized = this.requireNonEmpty(sourceName, 'sourceName').toLowerCase();
+        const knownSources = new Set((await this.getRegisteredSources()).map((source) => source.name));
+        if (!knownSources.has(normalized)) {
+            throw new error_types_1.ValidationError(`Unknown skill source: ${normalized}`, { sourceName: normalized });
+        }
+        return normalized;
+    }
+    isUniqueConstraintError(error) {
+        const code = this.readErrorCode(error);
+        const message = this.readErrorMessage(error);
+        return (code === 'SQLITE_CONSTRAINT' ||
+            code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+            code === 19 ||
+            message.includes('UNIQUE constraint failed'));
+    }
+    isForeignKeyConstraintError(error) {
+        const code = this.readErrorCode(error);
+        const message = this.readErrorMessage(error);
+        return (code === 'SQLITE_CONSTRAINT_FOREIGNKEY' ||
+            code === 'SQLITE_CONSTRAINT' ||
+            code === 19 ||
+            message.includes('FOREIGN KEY constraint failed'));
+    }
+    readErrorCode(error) {
+        if (typeof error !== 'object' || error === null || !('code' in error)) {
+            return undefined;
+        }
+        const code = error.code;
+        if (typeof code === 'string' || typeof code === 'number') {
+            return code;
+        }
+        return undefined;
+    }
+    readErrorMessage(error) {
+        if (typeof error !== 'object' || error === null || !('message' in error)) {
+            return '';
+        }
+        const message = error.message;
+        return typeof message === 'string' ? message : '';
+    }
+};
+exports.SkillsService = SkillsService;
+exports.SkillsService = SkillsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
+    __metadata("design:paramtypes", [Function, settings_service_1.SettingsService,
+        skill_source_registry_service_1.SkillSourceRegistryService])
+], SkillsService);
+//# sourceMappingURL=skills.service.js.map