@pattern-stack/frontend-patterns 0.1.0 → 0.1.2

package/cli/src/codegen/openapi/confidence-scorer.js

@@ -1,204 +0,0 @@
-"use strict";
-/**
- * Confidence scoring for generated hook names
- * Helps identify names that may need human review
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfidenceScorer = void 0;
-class ConfidenceScorer {
-    /**
-     * Score a generated hook name based on various quality indicators
-     */
-    scoreHookName(generatedName, originalOperationId, path, method) {
-        const issues = [];
-        const suggestions = [];
-        let score = 100;
-        // Check for camelCase issues
-        if (!this.isProperCamelCase(generatedName)) {
-            score -= 20;
-            issues.push('Improper camelCase formatting');
-        }
-        // Check for consecutive uppercase letters (like "useAssignRolesusersUserRoles")
-        if (this.hasConsecutiveUppercase(generatedName)) {
-            score -= 30;
-            issues.push('Consecutive uppercase letters suggest concatenation issues');
-            suggestions.push(this.suggestFixForConsecutiveUppercase(generatedName));
-        }
-        // Check for overly long names
-        const nameLength = generatedName.length;
-        if (nameLength > 30) {
-            score -= 20;
-            issues.push(`Name is too long (${nameLength} chars)`);
-        }
-        // Check for repeated words
-        if (this.hasRepeatedWords(generatedName)) {
-            score -= 25;
-            issues.push('Contains repeated word segments');
-        }
-        // Check if it matches common patterns
-        if (this.matchesCommonPattern(generatedName, method)) {
-            score += 10;
-            score = Math.min(score, 100); // Cap at 100
-        }
-        // Check for word boundaries issues
-        if (this.hasWordBoundaryIssues(generatedName)) {
-            score -= 15;
-            issues.push('Potential word boundary issues');
-        }
-        // Determine confidence level
-        let confidence;
-        if (score >= 80) {
-            confidence = 'high';
-        }
-        else if (score >= 60) {
-            confidence = 'medium';
-        }
-        else {
-            confidence = 'low';
-        }
-        return {
-            name: generatedName,
-            confidence,
-            score,
-            issues,
-            suggestions: suggestions.filter(s => s !== generatedName)
-        };
-    }
-    isProperCamelCase(name) {
-        // Should start with lowercase 'use'
-        if (!name.startsWith('use'))
-            return false;
-        // Check for proper camelCase pattern
-        const afterUse = name.substring(3);
-        return /^[A-Z][a-zA-Z0-9]*$/.test(afterUse);
-    }
-    hasConsecutiveUppercase(name) {
-        // Look for patterns like "RolesUsers" which suggest poor concatenation
-        return /[A-Z]{2,}[a-z]/.test(name) || /[a-z][A-Z]{2,}/.test(name);
-    }
-    hasRepeatedWords(name) {
-        // Convert camelCase to words
-        const words = this.camelCaseToWords(name).map(w => w.toLowerCase());
-        const uniqueWords = new Set(words);
-        // If we have significantly fewer unique words, there's repetition
-        return words.length > uniqueWords.size + 1; // Allow one repeat
-    }
-    matchesCommonPattern(name, method) {
-        const commonPatterns = {
-            get: /^use[A-Z][a-zA-Z]+$/,
-            post: /^useCreate[A-Z][a-zA-Z]+$/,
-            put: /^useUpdate[A-Z][a-zA-Z]+$/,
-            patch: /^useUpdate[A-Z][a-zA-Z]+$/,
-            delete: /^useDelete[A-Z][a-zA-Z]+$/
-        };
-        const pattern = commonPatterns[method];
-        return pattern ? pattern.test(name) : false;
-    }
-    hasWordBoundaryIssues(name) {
-        // Look for lowercase letters followed by uppercase without proper boundaries
-        // Exclude common patterns like "useCreate", "useUpdate", etc.
-        const afterUse = name.substring(3);
-        const knownPrefixes = ['Create', 'Update', 'Delete', 'Get', 'List', 'Fetch', 'Assign', 'Reassign'];
-        for (const prefix of knownPrefixes) {
-            if (afterUse.startsWith(prefix)) {
-                const remaining = afterUse.substring(prefix.length);
-                // Check for patterns like "Rolesusers" or "Budgettransactions"
-                if (/[a-z]{2,}[A-Z]/.test(remaining)) {
-                    return true;
-                }
-            }
-        }
-        // Check for lowercase word running into uppercase (3+ lowercase chars)
-        if (/[a-z]{3,}[A-Z]/.test(afterUse)) {
-            return true;
-        }
-        // Check for patterns like "RolesusersUser" where we have clear word concatenation
-        if (/[A-Z][a-z]+[a-z][A-Z]/.test(afterUse)) {
-            return true;
-        }
-        return false;
-    }
-    suggestFixForConsecutiveUppercase(name) {
-        // Try to fix patterns like "useAssignRolesusersUserRoles"
-        // This is a simple heuristic - the review process will catch if it's wrong
-        let suggestion = name;
-        // Specific fixes for known patterns
-        const knownFixes = {
-            'useAssignRolesusersUserRoles': 'useAssignUserRoles',
-            'useReassignBudgettransactionsReassignBudget': 'useReassignTransactionBudget',
-            'useCategorySubcategories': 'useCreateSubcategory'
-        };
-        if (knownFixes[name]) {
-            return knownFixes[name];
-        }
-        // Fix patterns where lowercase runs into uppercase (like "Rolesusers")
-        suggestion = suggestion.replace(/([a-z]{2,})([A-Z])/g, (match, p1, p2) => {
-            // If the lowercase part is a known word ending, add proper boundary
-            if (p1.endsWith('roles') || p1.endsWith('users') || p1.endsWith('budget')) {
-                return p1 + p2;
-            }
-            return match;
-        });
-        // Try to extract the main action and resource
-        const parts = this.camelCaseToWords(suggestion);
-        if (parts.length > 4) {
-            // Likely too many parts, try to simplify
-            // Keep: use + action + main resource
-            const action = parts[1]; // After 'use'
-            const resources = parts.slice(2);
-            // Find the most significant resource (usually the last one that's not a duplicate)
-            const uniqueResources = [...new Set(resources.map(r => r.toLowerCase()))];
-            if (uniqueResources.length === 1) {
-                return `use${action}${resources[resources.length - 1]}`;
-            }
-        }
-        return suggestion;
-    }
-    camelCaseToWords(str) {
-        // Split camelCase into words
-        return str
-            .replace(/([a-z])([A-Z])/g, '$1 $2')
-            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-            .split(' ')
-            .filter(w => w.length > 0);
-    }
-    /**
-     * Generate a confidence report for review
-     */
-    generateReport(scoredNames) {
-        const byConfidence = {
-            high: scoredNames.filter(s => s.confidence === 'high'),
-            medium: scoredNames.filter(s => s.confidence === 'medium'),
-            low: scoredNames.filter(s => s.confidence === 'low')
-        };
-        let report = '# Hook Name Generation Report\n\n';
-        report += `Generated ${scoredNames.length} hooks\n\n`;
-        report += `- High confidence: ${byConfidence.high.length}\n`;
-        report += `- Medium confidence: ${byConfidence.medium.length}\n`;
-        report += `- Low confidence: ${byConfidence.low.length}\n\n`;
-        if (byConfidence.low.length > 0) {
-            report += '## Low Confidence Names (Review Recommended)\n\n';
-            for (const scored of byConfidence.low) {
-                report += `### ${scored.name}\n`;
-                report += `- Score: ${scored.score}/100\n`;
-                report += `- Issues: ${scored.issues.join(', ')}\n`;
-                if (scored.suggestions.length > 0) {
-                    report += `- Suggestions: ${scored.suggestions.join(', ')}\n`;
-                }
-                report += '\n';
-            }
-        }
-        if (byConfidence.medium.length > 0) {
-            report += '## Medium Confidence Names (Optional Review)\n\n';
-            for (const scored of byConfidence.medium) {
-                report += `- ${scored.name} (${scored.score}/100)\n`;
-                if (scored.issues.length > 0) {
-                    report += `  Issues: ${scored.issues.join(', ')}\n`;
-                }
-            }
-            report += '\n';
-        }
-        return report;
-    }
-}
-exports.ConfidenceScorer = ConfidenceScorer;

package/cli/src/codegen/openapi/hook-config.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Hook generation configuration system
- * Stores learned patterns and manual overrides for hook name generation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookConfigManager = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const DEFAULT_CONFIG = {
-    version: '1.0.0',
-    nameOverrides: {},
-    reviewedNames: [],
-    patterns: {
-        removeDoubleWords: true,
-        smartCasing: true,
-        deduplicateSegments: true
-    }
-};
-class HookConfigManager {
-    constructor(configPath = './hooks.config.json') {
-        this.config = DEFAULT_CONFIG;
-        this.configPath = (0, path_1.resolve)(configPath);
-    }
-    async load() {
-        try {
-            const content = await fs_1.promises.readFile(this.configPath, 'utf8');
-            this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
-        }
-        catch (error) {
-            // File doesn't exist, use defaults
-            this.config = DEFAULT_CONFIG;
-        }
-    }
-    async save() {
-        const content = JSON.stringify(this.config, null, 2);
-        await fs_1.promises.writeFile(this.configPath, content, 'utf8');
-    }
-    getOverride(operationId) {
-        return this.config.nameOverrides[operationId];
-    }
-    addOverride(override) {
-        this.config.nameOverrides[override.original] = override.override;
-        this.config.reviewedNames.push({
-            ...override,
-            approvedAt: new Date().toISOString()
-        });
-    }
-    getPatterns() {
-        return this.config.patterns;
-    }
-    updateStatistics(stats) {
-        this.config.statistics = {
-            ...this.config.statistics,
-            ...stats,
-            lastUpdated: new Date().toISOString()
-        };
-    }
-    getReviewedNames() {
-        return this.config.reviewedNames;
-    }
-    hasBeenReviewed(operationId) {
-        return operationId in this.config.nameOverrides;
-    }
-}
-exports.HookConfigManager = HookConfigManager;