@pattern-stack/frontend-patterns 0.1.3 → 0.2.0-alpha.1

package/cli/src/codegen/openapi/client-generator.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * API Client Generator
  *
@@ -7,10 +6,11 @@
  *
  * Part of FRO-12: API Client Generator
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIClientGenerator = void 0;
-exports.generateAPIClient = generateAPIClient;
-class APIClientGenerator {
+import { singularize, pluralize, isPlural } from './naming-utils.js';
+import { AUTH_ACTIONS, HEALTH_ENDPOINTS, USER_PROFILE_ENDPOINTS, SINGLETON_RESOURCES, COLLECTION_ACTIONS } from './naming-constants.js';
+
+export class APIClientGenerator {
+    options;
     constructor(options = {}) {
         this.options = {
             clientType: options.clientType || 'axios',
@@ -42,7 +42,7 @@ class APIClientGenerator {
     generateAxiosClient() {
         return `/**
  * Axios API Client
- * 
+ *
  * Auto-generated API client with interceptors and error handling
  */
 
@@ -149,7 +149,7 @@ export class APIClient {
     generateFetchClient() {
         return `/**
  * Fetch API Client
- * 
+ *
  * Auto-generated API client using native fetch with error handling
  */
 
@@ -169,7 +169,7 @@ export class APIClient {
   ): Promise<T> {
     try {
       const fullUrl = this.buildUrl(url, options.params)
-      
+
       const fetchOptions: RequestInit = {
         method,
         headers: {
@@ -208,7 +208,7 @@ export class APIClient {
 
   private buildUrl(path: string, params?: Record<string, any>): string {
     const url = new URL(path, this.config.baseUrl)
-    
+
     if (params) {
       Object.entries(params).forEach(([key, value]) => {
         if (value !== undefined && value !== null) {
@@ -328,7 +328,7 @@ export class APIClient {
   private shouldRetry(error: AxiosError): boolean {
     const retryCount = (error.config as any)?._retryCount || 0
     const maxRetries = this.config.retries || ${this.options.retries}
-    
+
     return (
       retryCount < maxRetries &&
       (!error.response || error.response.status >= 500) &&
@@ -338,11 +338,11 @@ export class APIClient {
 
   private async retryRequest(config: any): Promise<any> {
     config._retryCount = (config._retryCount || 0) + 1
-    
+
     // Exponential backoff
     const delay = Math.pow(2, config._retryCount) * 1000
     await new Promise(resolve => setTimeout(resolve, delay))
-    
+
     return this.client.request(config)
   }`;
     }
@@ -503,7 +503,7 @@ export class APIClient {
         const authTypes = this.generateAuthTypes();
         return `/**
  * API Client Types
- * 
+ *
  * Configuration and utility types for the generated API client
  */
 
@@ -559,7 +559,7 @@ export interface APIError {
     generateConfiguration() {
         return `/**
  * API Client Configuration
- * 
+ *
  * Default configuration and factory functions
  */
 
@@ -583,7 +583,7 @@ export const defaultConfig: Partial<APIClientConfig> = {
     generateIndexFile() {
         return `/**
  * Generated API Client
- * 
+ *
  * Auto-generated from OpenAPI specification
  */
 
@@ -591,34 +591,90 @@ export * from './client'
 export * from './methods'
 export * from './types'
 export * from './config'
-export { createAPIClient, defaultConfig } from './config'
-
-// Singleton instance for convenient usage
-export const apiClient = createAPIClient({
-  baseUrl: process.env.VITE_API_URL || '${this.options.baseUrl || 'http://localhost:8080'}',
-  timeout: ${this.options.timeout},
-  defaultHeaders: {
-    'Content-Type': 'application/json'
-  }
-})`;
+export { createAPIClient, defaultConfig } from './config'`;
     }
     generateFileHeader(title) {
         return `/**
  * ${title}
- * 
+ *
  * Auto-generated from OpenAPI specification
  * Do not edit manually
  */`;
     }
     getMethodName(endpoint) {
-        if (endpoint.operationId) {
-            return this.camelCase(endpoint.operationId);
+        // Use semantic naming instead of raw operationId
+        return this.generateSemanticMethodName(endpoint);
+    }
+    generateSemanticMethodName(endpoint) {
+        // Extract resource from path
+        const pathSegments = endpoint.path.split('/').filter(s => s && !s.startsWith('{') && !['api', 'v1', 'v2'].includes(s));
+        const urlSegments = endpoint.path.split('/');
+        const hasPathParam = endpoint.path.includes('{');
+        const lastSegment = pathSegments[pathSegments.length - 1]?.replace(/-/g, '_') || 'resource';
+        const prevSegment = pathSegments[pathSegments.length - 2]?.replace(/-/g, '_');
+
+        // Auth endpoints - use action name directly
+        if (AUTH_ACTIONS.includes(lastSegment.toLowerCase())) {
+            return this.camelCase(lastSegment);
+        }
+
+        // Health/status singletons
+        if (HEALTH_ENDPOINTS.includes(lastSegment.toLowerCase())) {
+            return this.camelCase(lastSegment);
+        }
+
+        // User profile singletons
+        if (USER_PROFILE_ENDPOINTS.includes(lastSegment.toLowerCase())) {
+            return this.camelCase(`get_current_user`);
+        }
+
+        // Metadata endpoints - include parent resource to avoid collision
+        if (lastSegment.toLowerCase() === 'metadata' && prevSegment) {
+            return hasPathParam
+                ? this.camelCase(`get_${singularize(prevSegment)}_metadata`)
+                : this.camelCase(`get_${prevSegment}_metadata`);
+        }
+
+        // Collection actions (e.g., /activities/search)
+        if (COLLECTION_ACTIONS.includes(lastSegment.toLowerCase()) && prevSegment) {
+            return this.camelCase(`${lastSegment}_${prevSegment}`);
+        }
+
+        // Determine resource name - for nested paths, include context
+        let resource = lastSegment;
+        if (pathSegments.length > 2 && hasPathParam) {
+            // e.g., /accounts/{id}/stages/allowed → get_account_allowed_stages
+            const parentResource = pathSegments.find((s, i) => {
+                const nextSeg = urlSegments[urlSegments.findIndex(u => u === s) + 1];
+                return nextSeg?.startsWith('{');
+            });
+            if (parentResource && parentResource !== lastSegment) {
+                resource = `${singularize(parentResource)}_${lastSegment}`;
+            }
+        }
+
+        // Generate name based on HTTP method
+        switch (endpoint.method) {
+            case 'get':
+                return hasPathParam
+                    ? this.camelCase(`get_${singularize(resource)}`)
+                    : this.camelCase(`list_${resource}`);
+            case 'post':
+                // Check for custom actions like /accounts/{id}/stage
+                const lastUrl = urlSegments[urlSegments.length - 1];
+                const prevUrl = urlSegments[urlSegments.length - 2];
+                if (!lastUrl.startsWith('{') && prevUrl?.startsWith('{')) {
+                    return this.camelCase(`${lastUrl}_${singularize(prevSegment || resource)}`);
+                }
+                return this.camelCase(`create_${singularize(resource)}`);
+            case 'put':
+            case 'patch':
+                return this.camelCase(`update_${singularize(resource)}`);
+            case 'delete':
+                return this.camelCase(`delete_${singularize(resource)}`);
+            default:
+                return this.camelCase(`${endpoint.method}_${resource}`);
         }
-        const pathParts = endpoint.path
-            .split('/')
-            .filter(part => part && !part.startsWith('{'))
-            .map(part => this.capitalize(part));
-        return this.camelCase(`${endpoint.method}_${pathParts.join('_')}`);
     }
     generatePathWithParams(endpoint) {
         return endpoint.path.replace(/{([^}]+)}/g, '${$1}');
@@ -664,9 +720,8 @@ export const apiClient = createAPIClient({
         return str.charAt(0).toUpperCase() + str.slice(1);
     }
 }
-exports.APIClientGenerator = APIClientGenerator;
 // Factory function
-function generateAPIClient(parsedAPI, options) {
+export function generateAPIClient(parsedAPI, options) {
     const generator = new APIClientGenerator(options);
     return generator.generate(parsedAPI);
 }

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

@@ -1,204 +1,93 @@
-"use strict";
 /**
- * Confidence scoring for generated hook names
- * Helps identify names that may need human review
+ * Confidence Scorer (Stub)
+ *
+ * Scores generated hook names for quality/confidence.
+ * This is a minimal stub that returns high confidence for all names.
  */
-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;
+
+export class ConfidenceScorer {
+  constructor() {
+    this.scoringRules = [];
+  }
+
+  /**
+   * Score a generated hook name
+   * @returns {{ hookName: string, operationId: string, confidence: string, score: number, suggestions: string[] }}
+   */
+  scoreHookName(hookName, operationId, path, method) {
+    // Simple heuristic: shorter names are better
+    const lengthScore = Math.max(0, 100 - hookName.length);
+
+    // Check for common anti-patterns
+    const hasApiV1 = hookName.toLowerCase().includes('apiv1');
+    const hasUnderscore = hookName.includes('_');
+    const isVeryLong = hookName.length > 40;
+
+    let score = lengthScore;
+    if (hasApiV1) score -= 30;
+    if (hasUnderscore) score -= 10;
+    if (isVeryLong) score -= 20;
+
+    // Normalize to 0-100
+    score = Math.max(0, Math.min(100, score));
+
+    // Determine confidence level
+    let confidence;
+    if (score >= 70) confidence = 'high';
+    else if (score >= 40) confidence = 'medium';
+    else confidence = 'low';
+
+    return {
+      hookName,
+      operationId,
+      path,
+      method,
+      confidence,
+      score,
+      suggestions: confidence === 'low' ? [this.suggestBetterName(path, method)] : []
+    };
+  }
+
+  suggestBetterName(path, method) {
+    // Extract resource from path
+    const segments = path.split('/').filter(s => s && !s.startsWith('{') && !['api', 'v1'].includes(s));
+    const resource = segments[segments.length - 1]?.replace(/-/g, '') || 'resource';
+
+    // Capitalize first letter
+    const capitalizedResource = resource.charAt(0).toUpperCase() + resource.slice(1);
+
+    switch (method) {
+      case 'get':
+        return path.includes('{') ? `useGet${capitalizedResource}` : `use${capitalizedResource}`;
+      case 'post':
+        return `useCreate${capitalizedResource}`;
+      case 'put':
+      case 'patch':
+        return `useUpdate${capitalizedResource}`;
+      case 'delete':
+        return `useDelete${capitalizedResource}`;
+      default:
+        return `use${capitalizedResource}`;
     }
+  }
+
+  generateReport(scoredNames) {
+    const high = scoredNames.filter(s => s.confidence === 'high').length;
+    const medium = scoredNames.filter(s => s.confidence === 'medium').length;
+    const low = scoredNames.filter(s => s.confidence === 'low').length;
+
+    return `
+Hook Name Quality Report
+========================
+Total hooks: ${scoredNames.length}
+High confidence: ${high} (${Math.round(high/scoredNames.length*100)}%)
+Medium confidence: ${medium} (${Math.round(medium/scoredNames.length*100)}%)
+Low confidence: ${low} (${Math.round(low/scoredNames.length*100)}%)
+
+${low > 0 ? 'Low confidence hooks that may need review:\n' +
+  scoredNames.filter(s => s.confidence === 'low')
+    .map(s => `  - ${s.hookName} → suggested: ${s.suggestions[0]}`)
+    .join('\n') : 'All hooks have acceptable names!'}
+`;
+  }
 }
-exports.ConfidenceScorer = ConfidenceScorer;

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

@@ -1,66 +1,48 @@
-"use strict";
 /**
- * Hook generation configuration system
- * Stores learned patterns and manual overrides for hook name generation
+ * Hook Configuration Manager (Stub)
+ *
+ * Provides name overrides and pattern configuration for hook generation.
+ * This is a minimal stub to unblock the hook generator.
  */
-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;
-    }
+
+export class HookConfigManager {
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.overrides = {};
+    this.patterns = {
+      deduplicateSegments: true
+    };
+    this.reviewedNames = [];
+    this.statistics = {};
+  }
+
+  async load() {
+    // No-op for stub - would load from config file
+    return;
+  }
+
+  async save() {
+    // No-op for stub - would save to config file
+    return;
+  }
+
+  getOverride(operationId) {
+    return this.overrides[operationId] || null;
+  }
+
+  getPatterns() {
+    return this.patterns;
+  }
+
+  getReviewedNames() {
+    return this.reviewedNames;
+  }
+
+  updateStatistics(stats) {
+    this.statistics = { ...this.statistics, ...stats };
+  }
+
+  setOverride(operationId, hookName) {
+    this.overrides[operationId] = hookName;
+  }
 }
-exports.HookConfigManager = HookConfigManager;