@gulibs/safe-coder 0.0.26 → 0.0.27

package/dist/documentation/skill-generator.js

@@ -1,642 +0,0 @@
-import { writeFile, mkdir, access, constants } from 'fs/promises';
-import { join, resolve, basename } from 'path';
-export class SkillGenerator {
-    CONTENT_PREVIEW_LENGTH = 500;
-    MIN_CATEGORIZATION_SCORE = 2;
-    MIN_CONTENT_LENGTH = 100; // Minimum characters for valid content
-    MIN_HEADINGS_COUNT = 1; // Minimum headings for structured content
-    /**
-     * Generate agent skill from crawled documentation
-     */
-    generateSkill(crawlResult, rootUrl, skillName) {
-        const { pages, totalPages, maxDepthReached, errors } = crawlResult;
-        if (pages.length === 0) {
-            throw new Error('No pages were successfully crawled');
-        }
-        // Validate if content is sufficient for skill generation
-        const validation = this.canGenerateSkill(pages);
-        if (!validation.canGenerate) {
-            throw new Error(`Cannot generate skill: ${validation.reason}. ` +
-                `Pages crawled: ${totalPages}, but content is insufficient. ` +
-                `Consider crawling more pages or a different website.`);
-        }
-        // Generate skill name
-        const name = skillName || this.generateSkillName(rootUrl, pages[0]);
-        // Generate title from root URL or first page
-        const title = this.extractTitle(rootUrl, pages[0]);
-        // Generate description (truncated to 1024 chars)
-        const description = this.generateDescription(rootUrl, pages, totalPages, maxDepthReached);
-        const truncatedDescription = description.length > 1024 ? description.substring(0, 1021) + '...' : description;
-        // Validate description quality
-        this.validateDescription(truncatedDescription);
-        // Categorize pages
-        const categories = this.categorizePages(pages);
-        // Generate reference files
-        const referenceFiles = this.generateReferenceFiles(categories, name);
-        // Generate SKILL.md with YAML frontmatter
-        const skillMd = this.generateSkillMd(name, truncatedDescription, categories, pages);
-        // Generate metadata
-        const metadata = {
-            title,
-            description: truncatedDescription,
-            sourceUrl: rootUrl,
-            pagesCrawled: totalPages,
-            maxDepthReached,
-            generatedAt: new Date().toISOString(),
-            sourceUrls: pages.map(p => p.url),
-        };
-        return {
-            skillMd,
-            referenceFiles,
-            metadata,
-            skillName: name,
-        };
-    }
-    /**
-     * Generate skill name from URL or provided name (sanitized)
-     */
-    generateSkillName(rootUrl, firstPage) {
-        try {
-            const url = new URL(rootUrl);
-            const hostname = url.hostname.replace('www.', '').replace(/\./g, '-');
-            const pathParts = url.pathname.split('/').filter(p => p && p !== 'docs' && p !== 'documentation');
-            const pathPart = pathParts.length > 0 ? pathParts[pathParts.length - 1] : 'docs';
-            // Sanitize: lowercase, hyphens only, max 64 chars
-            const sanitized = `${hostname}-${pathPart}`
-                .toLowerCase()
-                .replace(/[^a-z0-9-]/g, '-')
-                .replace(/-+/g, '-')
-                .replace(/^-|-$/g, '')
-                .substring(0, 64);
-            return sanitized || 'documentation-skill';
-        }
-        catch {
-            // Fallback to page title
-            const fromTitle = (firstPage.title || 'documentation')
-                .toLowerCase()
-                .replace(/[^a-z0-9-]/g, '-')
-                .replace(/-+/g, '-')
-                .replace(/^-|-$/g, '')
-                .substring(0, 64);
-            return fromTitle || 'documentation-skill';
-        }
-    }
-    /**
-     * Extract title from URL or first page
-     */
-    extractTitle(rootUrl, firstPage) {
-        try {
-            const url = new URL(rootUrl);
-            const hostname = url.hostname.replace('www.', '');
-            const pathParts = url.pathname.split('/').filter(p => p);
-            if (pathParts.length > 0) {
-                const lastPart = pathParts[pathParts.length - 1];
-                return `${hostname} - ${this.capitalize(lastPart)} Documentation`;
-            }
-            return `${hostname} Documentation`;
-        }
-        catch {
-            return firstPage.title || 'Documentation';
-        }
-    }
-    /**
-     * Generate description with "when to use" triggers and keywords extracted from pages
-     * Description must be comprehensive, include triggers, and stay within 1024 chars
-     */
-    generateDescription(rootUrl, pages, totalPages, maxDepth) {
-        // Extract key topics and concepts from pages
-        const topics = this.extractKeyTopics(pages);
-        const categories = this.inferCategories(pages);
-        const categoryNames = Array.from(categories.keys());
-        // Build description components
-        const parts = [];
-        // What the skill provides
-        const domainName = this.extractDomainName(rootUrl);
-        parts.push(`Comprehensive documentation for ${domainName}`);
-        // Extract use cases from page titles and categories
-        const useCases = this.extractUseCases(pages, categoryNames);
-        if (useCases.length > 0) {
-            // Format use cases more naturally
-            const useCaseText = useCases.length === 1
-                ? useCases[0]
-                : useCases.slice(0, -1).join(', ') + (useCases.length > 1 ? `, and ${useCases[useCases.length - 1]}` : '');
-            parts.push(`Use when working with ${domainName} ${useCaseText}`);
-        }
-        // Add specific triggers/keywords based on categories and topics
-        const triggers = this.generateTriggers(categoryNames, topics);
-        if (triggers.length > 0) {
-            // Include triggers naturally in the description
-            const triggerText = triggers.slice(0, 5).join(', ');
-            parts.push(`Includes documentation for ${triggerText}`);
-        }
-        // Add metadata (crawled info) - keep it brief
-        parts.push(`Generated from ${rootUrl} (${totalPages} pages, depth ${maxDepth})`);
-        // Join and truncate to 1024 chars, preserving key information
-        let description = parts.join('. ');
-        if (description.length > 1024) {
-            // Prioritize: what it does + use cases + triggers, then metadata
-            const essential = `${parts[0]}. ${parts[1] || ''}${parts[2] ? `. ${parts[2]}` : ''}`;
-            const metadata = parts[3] || '';
-            const available = 1024 - essential.length - metadata.length - 10; // 10 for spacing/ellipsis
-            if (available > 0 && metadata.length > available) {
-                description = `${essential}. ${metadata.substring(0, available)}...`;
-            }
-            else {
-                description = `${essential}. ${metadata}`.substring(0, 1021) + '...';
-            }
-        }
-        return description;
-    }
-    /**
-     * Extract key topics from page titles, headings, and content
-     */
-    extractKeyTopics(pages) {
-        const topicSet = new Set();
-        const commonWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from', 'as', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'may', 'might', 'must', 'can', 'this', 'that', 'these', 'those', 'what', 'which', 'who', 'when', 'where', 'why', 'how', 'get', 'got', 'go', 'goes', 'went', 'come', 'comes', 'came', 'see', 'saw', 'know', 'knows', 'knew', 'think', 'thinks', 'thought', 'take', 'takes', 'took', 'make', 'makes', 'made', 'use', 'uses', 'used', 'work', 'works', 'worked', 'call', 'calls', 'called']);
-        // Extract from titles
-        for (const page of pages.slice(0, 20)) { // Limit to first 20 pages for performance
-            const titleWords = (page.title || '').toLowerCase().split(/\s+/)
-                .filter(w => w.length > 3 && !commonWords.has(w))
-                .slice(0, 5);
-            titleWords.forEach(w => topicSet.add(w));
-        }
-        // Extract from headings
-        for (const page of pages.slice(0, 20)) {
-            if (page.headings) {
-                for (const heading of page.headings.slice(0, 10)) {
-                    const headingWords = (heading.text || '').toLowerCase().split(/\s+/)
-                        .filter(w => w.length > 3 && !commonWords.has(w))
-                        .slice(0, 3);
-                    headingWords.forEach(w => topicSet.add(w));
-                }
-            }
-        }
-        return Array.from(topicSet).slice(0, 10); // Limit to top 10 topics
-    }
-    /**
-     * Extract domain name from URL
-     */
-    extractDomainName(rootUrl) {
-        try {
-            const url = new URL(rootUrl);
-            const hostname = url.hostname.replace('www.', '');
-            const pathParts = url.pathname.split('/').filter(p => p && !['docs', 'documentation', 'en', 'stable', 'latest'].includes(p));
-            if (pathParts.length > 0) {
-                return `${hostname} ${pathParts[pathParts.length - 1]}`;
-            }
-            return hostname;
-        }
-        catch {
-            return 'documentation';
-        }
-    }
-    /**
-     * Extract use cases from pages and categories
-     */
-    extractUseCases(pages, categoryNames) {
-        const useCases = [];
-        // Map categories to use cases
-        const categoryToUseCase = {
-            'api': 'for API reference and methods',
-            'tutorials': 'for tutorials and learning',
-            'tutorial': 'for tutorials and learning',
-            'guide': 'for guides and how-tos',
-            'getting-started': 'for getting started',
-            'reference': 'for reference documentation',
-            'examples': 'for code examples',
-        };
-        for (const cat of categoryNames) {
-            const useCase = categoryToUseCase[cat.toLowerCase()];
-            if (useCase && !useCases.includes(useCase)) {
-                useCases.push(useCase);
-            }
-        }
-        // If no specific use cases found, add generic ones
-        if (useCases.length === 0) {
-            useCases.push('for understanding concepts', 'for implementing features', 'for debugging code');
-        }
-        return useCases.slice(0, 3); // Limit to 3 use cases
-    }
-    /**
-     * Generate trigger keywords from categories and topics
-     */
-    generateTriggers(categoryNames, topics) {
-        const triggers = [];
-        // Add category-based triggers
-        for (const cat of categoryNames.slice(0, 3)) {
-            triggers.push(cat);
-        }
-        // Add top topics as triggers
-        for (const topic of topics.slice(0, 3)) {
-            if (!triggers.includes(topic)) {
-                triggers.push(topic);
-            }
-        }
-        return triggers.slice(0, 5); // Limit to 5 triggers
-    }
-    /**
-     * Categorize pages into categories based on URL patterns and content
-     */
-    categorizePages(pages) {
-        const categories = new Map();
-        const categoryDefs = this.inferCategories(pages);
-        // Initialize categories
-        for (const cat of categoryDefs.keys()) {
-            categories.set(cat, []);
-        }
-        categories.set('other', []);
-        // Categorize each page
-        for (const page of pages) {
-            const url = page.url.toLowerCase();
-            const title = page.title.toLowerCase();
-            const content = page.content.toLowerCase().substring(0, this.CONTENT_PREVIEW_LENGTH);
-            let categorized = false;
-            // Match against keywords
-            for (const [cat, keywords] of categoryDefs.entries()) {
-                let score = 0;
-                for (const keyword of keywords) {
-                    const lowerKeyword = keyword.toLowerCase();
-                    if (url.includes(lowerKeyword))
-                        score += 3;
-                    if (title.includes(lowerKeyword))
-                        score += 2;
-                    if (content.includes(lowerKeyword))
-                        score += 1;
-                }
-                if (score >= this.MIN_CATEGORIZATION_SCORE) {
-                    const catPages = categories.get(cat) || [];
-                    catPages.push(page);
-                    categories.set(cat, catPages);
-                    categorized = true;
-                    break;
-                }
-            }
-            if (!categorized) {
-                const otherPages = categories.get('other') || [];
-                otherPages.push(page);
-                categories.set('other', otherPages);
-            }
-        }
-        // Remove empty categories
-        for (const [cat, pages] of categories.entries()) {
-            if (pages.length === 0) {
-                categories.delete(cat);
-            }
-        }
-        return categories;
-    }
-    /**
-     * Infer categories from URL patterns
-     */
-    inferCategories(pages) {
-        const urlSegments = new Map();
-        for (const page of pages) {
-            try {
-                const url = new URL(page.url);
-                const segments = url.pathname
-                    .split('/')
-                    .filter(s => s && !['en', 'stable', 'latest', 'docs', 'documentation'].includes(s));
-                for (const seg of segments) {
-                    urlSegments.set(seg, (urlSegments.get(seg) || 0) + 1);
-                }
-            }
-            catch {
-                // Skip invalid URLs
-            }
-        }
-        // Top segments become categories
-        const sortedSegments = Array.from(urlSegments.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 8);
-        const categories = new Map();
-        for (const [seg, count] of sortedSegments) {
-            if (count >= 3) {
-                categories.set(seg, [seg]);
-            }
-        }
-        // Add common defaults
-        const allUrls = pages.map(p => p.url.toLowerCase());
-        if (!categories.has('tutorial') && allUrls.some(u => u.includes('tutorial'))) {
-            categories.set('tutorials', ['tutorial', 'guide', 'getting-started']);
-        }
-        if (!categories.has('api') && allUrls.some(u => u.includes('api') || u.includes('reference'))) {
-            categories.set('api', ['api', 'reference', 'class']);
-        }
-        return categories;
-    }
-    /**
-     * Generate reference files for each category
-     * Includes full content, code examples, and table of contents from headings
-     * Adds table of contents at the top for files longer than 100 lines
-     */
-    generateReferenceFiles(categories, skillName) {
-        const referenceFiles = new Map();
-        for (const [category, pages] of categories.entries()) {
-            if (pages.length === 0)
-                continue;
-            const lines = [];
-            lines.push(`# ${this.capitalize(skillName)} - ${category.replace('_', ' ').split('-').map(this.capitalize).join(' ')}\n`);
-            lines.push(`**Pages:** ${pages.length}\n`);
-            lines.push('---\n');
-            // Collect all page titles and headings for table of contents
-            const tocItems = [];
-            for (const page of pages) {
-                const headings = [];
-                if (page.headings && page.headings.length > 0) {
-                    for (const heading of page.headings) {
-                        const level = parseInt(heading.level.replace('h', ''));
-                        headings.push({ level, text: heading.text });
-                    }
-                }
-                tocItems.push({ title: page.title, url: page.url, headings });
-            }
-            // Generate content
-            for (const page of pages) {
-                lines.push(`## ${page.title}\n`);
-                lines.push(`**URL:** ${page.url}\n`);
-                // Table of contents from headings (per page)
-                if (page.headings && page.headings.length > 0) {
-                    lines.push('**Contents:**');
-                    for (const heading of page.headings.slice(0, 10)) {
-                        const level = parseInt(heading.level.replace('h', ''));
-                        const indent = '  '.repeat(Math.max(0, level - 2));
-                        lines.push(`${indent}- ${heading.text}`);
-                    }
-                    lines.push('');
-                }
-                // Full content (NO TRUNCATION)
-                if (page.content) {
-                    lines.push(page.content);
-                    lines.push('');
-                }
-                // Code examples with language (NO TRUNCATION)
-                if (page.codeSamples && page.codeSamples.length > 0) {
-                    lines.push('**Examples:**\n');
-                    for (let i = 0; i < Math.min(page.codeSamples.length, 4); i++) {
-                        const sample = page.codeSamples[i];
-                        const lang = sample.language || 'text';
-                        lines.push(`Example ${i + 1} (${lang}):`);
-                        lines.push(`\`\`\`${lang}`);
-                        lines.push(sample.code); // Full code, no truncation
-                        lines.push('```\n');
-                    }
-                }
-                lines.push('---\n');
-            }
-            const content = lines.join('\n');
-            const lineCount = content.split('\n').length;
-            // Add table of contents at the top for files longer than 100 lines
-            if (lineCount > 100 && tocItems.length > 0) {
-                const tocLines = [];
-                tocLines.push('## Table of Contents\n');
-                for (const item of tocItems) {
-                    tocLines.push(`- [${item.title}](#${this.slugify(item.title)})`);
-                    // Add sub-headings for major sections
-                    for (const heading of item.headings.slice(0, 3)) {
-                        if (heading.level <= 3) {
-                            const indent = '  '.repeat(heading.level - 2);
-                            tocLines.push(`${indent}- [${heading.text}](#${this.slugify(heading.text)})`);
-                        }
-                    }
-                }
-                tocLines.push('');
-                tocLines.push('---\n');
-                referenceFiles.set(category, tocLines.join('\n') + content);
-            }
-            else {
-                referenceFiles.set(category, content);
-            }
-        }
-        return referenceFiles;
-    }
-    /**
-     * Generate SKILL.md with YAML frontmatter
-     * Optimized for progressive disclosure - concise body focused on procedural instructions
-     */
-    generateSkillMd(skillName, description, categories, allPages) {
-        const lines = [];
-        // YAML frontmatter
-        lines.push('---');
-        lines.push(`name: ${skillName}`);
-        lines.push(`description: ${description}`);
-        lines.push('---');
-        lines.push('');
-        // Title
-        lines.push(`# ${this.capitalize(skillName)} Skill\n`);
-        // Quick Start / Overview
-        lines.push('## Overview\n');
-        lines.push('This skill provides comprehensive documentation extracted from official sources. Use the reference files below to access detailed information as needed.\n');
-        // Reference Files with clear guidance on when to read them
-        lines.push('## Reference Files\n');
-        lines.push('The following reference files contain organized documentation. Read them when you need specific information:\n');
-        const sortedCategories = Array.from(categories.keys()).sort();
-        for (const category of sortedCategories) {
-            const pages = categories.get(category) || [];
-            const categoryDisplay = category.replace('_', ' ').split('-').map(this.capitalize).join(' ');
-            const whenToRead = this.getWhenToReadGuidance(category);
-            lines.push(`- **[${category}.md](references/${category}.md)** - ${categoryDisplay} documentation (${pages.length} pages)`);
-            if (whenToRead) {
-                lines.push(`  - *Read when: ${whenToRead}*`);
-            }
-        }
-        lines.push('');
-        // Working with This Skill (procedural guidance)
-        lines.push('## Working with This Skill\n');
-        lines.push('### Getting Started');
-        const hasTutorials = sortedCategories.some(c => c.includes('tutorial') || c.includes('getting-started') || c.includes('guide'));
-        if (hasTutorials) {
-            lines.push('Start with tutorial or getting-started reference files for foundational concepts.');
-        }
-        else {
-            lines.push('Begin with the first reference file that matches your needs.');
-        }
-        lines.push('');
-        lines.push('### Finding Specific Information');
-        lines.push('Use the category reference files based on what you need:');
-        lines.push('- **API/Reference files**: For method signatures, parameters, and return types');
-        lines.push('- **Guide/Tutorial files**: For step-by-step instructions and examples');
-        lines.push('- **Other categories**: For domain-specific documentation');
-        lines.push('');
-        // Quick Reference (if applicable)
-        lines.push('## Quick Reference\n');
-        lines.push('Common patterns and examples are included in the reference files. Load the appropriate reference file to access code examples and detailed patterns.\n');
-        return lines.join('\n');
-    }
-    /**
-     * Get guidance on when to read a specific category reference file
-     */
-    getWhenToReadGuidance(category) {
-        const categoryLower = category.toLowerCase();
-        const guidance = {
-            'api': 'you need API reference, method signatures, or parameter details',
-            'reference': 'you need API reference or technical specifications',
-            'tutorials': 'you want step-by-step tutorials or learning guides',
-            'tutorial': 'you want step-by-step tutorials or learning guides',
-            'guide': 'you need how-to guides or implementation instructions',
-            'getting-started': 'you are new to the technology or need foundational concepts',
-            'examples': 'you need code examples or sample implementations',
-        };
-        // Check for partial matches
-        for (const [key, value] of Object.entries(guidance)) {
-            if (categoryLower.includes(key)) {
-                return value;
-            }
-        }
-        return null;
-    }
-    /**
-     * Save skill to file system in proper directory structure
-     * Prevents nested skill directories by checking if outputDir is already a skill directory
-     */
-    async saveSkill(skill, outputDir, filename) {
-        // Resolve output directory to absolute path
-        // If outputDir starts with '.', resolve relative to current working directory (project root)
-        // Otherwise, use resolve() which resolves relative to current working directory anyway
-        const resolvedOutputDir = outputDir.startsWith('.')
-            ? resolve(process.cwd(), outputDir)
-            : resolve(outputDir);
-        // Determine expected skill name
-        const expectedSkillName = filename
-            ? filename
-                .toLowerCase()
-                .replace(/[^a-z0-9-]/g, '-')
-                .replace(/-+/g, '-')
-                .replace(/^-|-$/g, '')
-                .substring(0, 64) || 'documentation-skill'
-            : skill.skillName.toLowerCase()
-                .replace(/[^a-z0-9-]/g, '-')
-                .replace(/-+/g, '-')
-                .replace(/^-|-$/g, '')
-                .substring(0, 64);
-        // Check if outputDir is already a skill directory (contains SKILL.md)
-        let skillDir;
-        try {
-            const skillMdPath = join(resolvedOutputDir, 'SKILL.md');
-            await access(skillMdPath, constants.F_OK);
-            // outputDir is already a skill directory, use it directly
-            skillDir = resolvedOutputDir;
-        }
-        catch {
-            // outputDir is not a skill directory
-            // Check if the last part of outputDir is already the skill name
-            // If so, use outputDir directly; otherwise create subdirectory
-            const outputDirBasename = basename(resolvedOutputDir);
-            if (outputDirBasename === expectedSkillName) {
-                // outputDir already ends with skill name, use it directly
-                skillDir = resolvedOutputDir;
-            }
-            else {
-                // Create new skill directory
-                skillDir = join(resolvedOutputDir, expectedSkillName);
-            }
-            await mkdir(skillDir, { recursive: true });
-        }
-        // Create references subdirectory
-        const referencesDir = join(skillDir, 'references');
-        await mkdir(referencesDir, { recursive: true });
-        // Create optional directories
-        const scriptsDir = join(skillDir, 'scripts');
-        const assetsDir = join(skillDir, 'assets');
-        await mkdir(scriptsDir, { recursive: true });
-        await mkdir(assetsDir, { recursive: true });
-        // Save SKILL.md
-        const skillMdPath = join(skillDir, 'SKILL.md');
-        await writeFile(skillMdPath, skill.skillMd, 'utf-8');
-        // Save reference files
-        const referenceFilePaths = [];
-        for (const [category, content] of skill.referenceFiles.entries()) {
-            const refFilePath = join(referencesDir, `${category}.md`);
-            await writeFile(refFilePath, content, 'utf-8');
-            referenceFilePaths.push(refFilePath);
-        }
-        return {
-            skillDir,
-            skillMdPath,
-            referenceFiles: referenceFilePaths,
-        };
-    }
-    /**
-     * Slugify text for anchor links
-     */
-    slugify(text) {
-        return text
-            .toLowerCase()
-            .replace(/[^\w\s-]/g, '')
-            .replace(/\s+/g, '-')
-            .replace(/-+/g, '-')
-            .trim();
-    }
-    /**
-     * Capitalize first letter
-     */
-    capitalize(text) {
-        return text.charAt(0).toUpperCase() + text.slice(1);
-    }
-    /**
-     * Check if crawled content is sufficient for skill generation
-     */
-    canGenerateSkill(pages) {
-        if (pages.length === 0) {
-            return { canGenerate: false, reason: 'empty_pages' };
-        }
-        // Check if any page has sufficient content
-        let hasSufficientContent = false;
-        let hasStructuredContent = false;
-        let hasTextContent = false;
-        let mediaOnlyCount = 0;
-        for (const page of pages) {
-            const contentLength = (page.content || '').trim().length;
-            const hasHeadings = page.headings && page.headings.length > 0;
-            const hasText = contentLength > 0;
-            // Check if page is media-only (has images but no text)
-            const hasImages = /<img[^>]*>/i.test(page.content || '');
-            const hasMedia = hasImages || (page.codeSamples && page.codeSamples.length > 0);
-            if (hasMedia && contentLength < this.MIN_CONTENT_LENGTH) {
-                mediaOnlyCount++;
-            }
-            if (contentLength >= this.MIN_CONTENT_LENGTH) {
-                hasSufficientContent = true;
-            }
-            if (hasHeadings) {
-                hasStructuredContent = true;
-            }
-            if (hasText) {
-                hasTextContent = true;
-            }
-        }
-        // All pages are media-only
-        if (mediaOnlyCount === pages.length && !hasTextContent) {
-            return { canGenerate: false, reason: 'media_only' };
-        }
-        // No pages have sufficient content
-        if (!hasSufficientContent) {
-            return { canGenerate: false, reason: 'insufficient_content' };
-        }
-        // No structured content (headings, sections)
-        if (!hasStructuredContent) {
-            return { canGenerate: false, reason: 'no_structured_content' };
-        }
-        return { canGenerate: true };
-    }
-    /**
-     * Validate description quality - checks length and presence of trigger keywords
-     */
-    validateDescription(description) {
-        // Check length
-        if (description.length > 1024) {
-            throw new Error(`Description exceeds 1024 character limit: ${description.length} characters`);
-        }
-        // Check for basic quality indicators (warnings only, don't fail)
-        const hasUseCase = /for:|when|use|working with/i.test(description);
-        const hasTriggers = /trigger|keyword|concept/i.test(description) || description.split(',').length >= 3;
-        const minLength = description.length >= 100; // At least 100 chars for meaningful description
-        // Log warnings if description seems too generic
-        if (!hasUseCase && !hasTriggers) {
-            console.warn('Description may be too generic - consider adding more specific triggers or use cases');
-        }
-        if (!minLength) {
-            console.warn('Description may be too short - consider adding more detail');
-        }
-    }
-}
-//# sourceMappingURL=skill-generator.js.map