@pattern-stack/frontend-patterns 0.0.5 → 0.1.0

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

@@ -0,0 +1,204 @@
+"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

@@ -0,0 +1,66 @@
+"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;