agent-skill-kit 3.9.135

package/.agent/skills/studio/scripts/utils/page-type-detector.ts

@@ -0,0 +1,124 @@
+// @ts-nocheck
+/**
+ * Page Type Detection - Studio Design System
+ * ===========================================
+ * Detects page types from context and search results
+ * Used by intelligent override generation (Phase 5)
+ * 
+ * Supports custom patterns via .studiorc.json or studio-config.json
+ */
+
+import { loadConfig, mergePatterns } from './config-loader.ts';
+
+/**
+ * Default page type patterns (exported for extension/override)
+ * NOTE: Order matters - more specific patterns should come first
+ */
+export const DEFAULT_PATTERNS = [
+    {
+        keywords: ['dashboard', 'admin', 'analytics', 'data', 'metrics', 'stats', 'monitor', 'overview'],
+        type: 'Dashboard / Data View'
+    },
+    {
+        keywords: ['checkout', 'payment', 'cart', 'purchase', 'order', 'billing'],
+        type: 'Checkout / Payment'
+    },
+    {
+        // IMPORTANT: Don't include 'account' here due to collision with 'register account' (Authentication)
+        keywords: ['settings', 'profile', 'preferences', 'config'],
+        type: 'Settings / Profile'
+    },
+    {
+        keywords: ['landing', 'marketing', 'homepage', 'hero', 'home', 'promo'],
+        type: 'Landing / Marketing'
+    },
+    {
+        // 'account' keyword handled here (for register/create account flows)
+        keywords: ['login', 'signin', 'signup', 'register', 'auth', 'password', 'account'],
+        type: 'Authentication'
+    },
+    {
+        // Added 'package' (singular) to match 'package options'
+        keywords: ['pricing', 'plans', 'subscription', 'tiers', 'packages', 'package'],
+        type: 'Pricing / Plans'
+    },
+    {
+        keywords: ['blog', 'article', 'post', 'news', 'content', 'story'],
+        type: 'Blog / Article'
+    },
+    {
+        keywords: ['product', 'item', 'detail', 'pdp', 'shop', 'store'],
+        type: 'Product Detail'
+    },
+    {
+        keywords: ['search', 'browse', 'filter', 'catalog', 'list'],
+        type: 'Search Results'
+    },
+    {
+        // IMPORTANT: 'results' removed to avoid collision with 'Search Results'
+        // 'zero results' should match on 'zero', not 'results'
+        keywords: ['empty', '404', 'error', 'not found', 'zero'],
+        type: 'Empty State'
+    }
+];
+
+/**
+ * Detect page type from context string and style results
+ * Uses DEFAULT_PATTERNS only (for backward compatibility)
+ * @param {string} context - Combined page name + query context
+ * @param {Array} styleResults - Style search results for fallback inference
+ * @returns {string} Detected page type
+ */
+export function detectPageType(context, styleResults = []) {
+    return detectPageTypeWithPatterns(context, styleResults, DEFAULT_PATTERNS);
+}
+
+/**
+ * Detect page type with custom patterns from config
+ * Loads user config and merges custom patterns (higher priority)
+ * @param {string} context - Combined page name + query context
+ * @param {Array} styleResults - Style search results for fallback inference
+ * @param {string} projectDir - Project directory to search for config
+ * @returns {Promise<string>} Detected page type
+ */
+export async function detectPageTypeWithConfig(context, styleResults = [], projectDir = process.cwd()) {
+    const config = await loadConfig(null, projectDir);
+    const customPatterns = config?.customPatterns || [];
+    const patterns = mergePatterns(DEFAULT_PATTERNS, customPatterns);
+    
+    return detectPageTypeWithPatterns(context, styleResults, patterns);
+}
+
+/**
+ * Core page type detection logic with configurable patterns
+ * @param {string} context - Combined page name + query context
+ * @param {Array} styleResults - Style search results for fallback inference
+ * @param {Array} patterns - Page patterns to match against
+ * @returns {string} Detected page type
+ */
+function detectPageTypeWithPatterns(context, styleResults, patterns) {
+    const contextLower = (context || '').toLowerCase();
+
+    // Check each pattern for keyword matches
+    for (const { keywords, type } of patterns) {
+        if (keywords.some(kw => contextLower.includes(kw))) {
+            return type;
+        }
+    }
+
+    // Fallback: try to infer from style results
+    if (styleResults && styleResults.length > 0) {
+        const styleName = (styleResults[0]['Style Category'] || '').toLowerCase();
+        const bestFor = (styleResults[0]['Best For'] || '').toLowerCase();
+
+        if (bestFor.includes('dashboard') || bestFor.includes('data')) {
+            return 'Dashboard / Data View';
+        } else if (bestFor.includes('landing') || bestFor.includes('marketing')) {
+            return 'Landing / Marketing';
+        }
+    }
+
+    // Final fallback
+    return 'General';
+}
+

package/.agent/skills/studio/scripts/utils/search-cache.ts

@@ -0,0 +1,165 @@
+/**
+ * Search Results Cache - Studio Design System
+ * =============================================
+ * LRU cache for search results to reduce CSV parsing overhead
+ */
+
+interface CacheEntry<T> {
+    value: T;
+    expiresAt: number;
+    createdAt: number;
+}
+
+/**
+ * Simple LRU (Least Recently Used) Cache implementation
+ */
+export class LRUCache<T = unknown> {
+    private maxSize: number;
+    private ttlMs: number;
+    private cache: Map<string, CacheEntry<T>>;
+
+    constructor(maxSize: number = 50, ttlMs: number = 5 * 60 * 1000) {
+        this.maxSize = maxSize;
+        this.ttlMs = ttlMs;
+        this.cache = new Map();
+    }
+
+    /**
+     * Generate cache key from search parameters
+     */
+    static generateKey(query: string, domain: string, maxResults: number): string {
+        const normalizedQuery = (query || '').toLowerCase().trim();
+        return `${normalizedQuery}:${domain}:${maxResults}`;
+    }
+
+    /**
+     * Get value from cache
+     */
+    get(key: string): T | undefined {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return undefined;
+        }
+
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+
+        // Move to end (most recently used)
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+
+        return entry.value;
+    }
+
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T): void {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+
+        if (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey) this.cache.delete(oldestKey);
+        }
+
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + this.ttlMs,
+            createdAt: Date.now()
+        });
+    }
+
+    /**
+     * Check if key exists and is not expired
+     */
+    has(key: string): boolean {
+        const entry = this.cache.get(key);
+        if (!entry) return false;
+
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return false;
+        }
+
+        return true;
+    }
+
+    /** Clear all cache entries */
+    clear(): void {
+        this.cache.clear();
+    }
+
+    /** Get current cache size */
+    get size(): number {
+        return this.cache.size;
+    }
+
+    /** Get cache statistics */
+    getStats(): { size: number; maxSize: number; ttlMs: number } {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            ttlMs: this.ttlMs
+        };
+    }
+}
+
+// Global cache instance for search results
+export const searchCache = new LRUCache(50, 5 * 60 * 1000);
+
+// Cache hit/miss statistics
+let cacheStats = {
+    hits: 0,
+    misses: 0
+};
+
+/**
+ * Wrap a search function with caching
+ */
+export function withCache<R>(
+    searchFn: (query: string, domain: string, maxResults: number) => Promise<R>,
+    domain: string
+): (query: string, maxResults?: number) => Promise<R> {
+    return async function cachedSearch(query: string, maxResults: number = 5): Promise<R> {
+        const key = LRUCache.generateKey(query, domain, maxResults);
+
+        const cachedResult = searchCache.get(key) as R | undefined;
+        if (cachedResult !== undefined) {
+            cacheStats.hits++;
+            return cachedResult;
+        }
+
+        cacheStats.misses++;
+        const result = await searchFn(query, domain, maxResults);
+
+        searchCache.set(key, result);
+
+        return result;
+    };
+}
+
+/**
+ * Clear the search cache
+ */
+export function clearSearchCache(): void {
+    searchCache.clear();
+    cacheStats = { hits: 0, misses: 0 };
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats(): { hits: number; misses: number; hitRate: string; cacheSize: number } {
+    const total = cacheStats.hits + cacheStats.misses;
+    return {
+        hits: cacheStats.hits,
+        misses: cacheStats.misses,
+        hitRate: total > 0 ? (cacheStats.hits / total * 100).toFixed(1) + '%' : '0%',
+        cacheSize: searchCache.size
+    };
+}

package/.agent/skills/studio/scripts/utils/text-utils.ts

@@ -0,0 +1,44 @@
+/**
+ * Text Utilities - Studio Scripts
+ * ================================
+ * Tokenization helpers for BM25 search
+ */
+
+import type { CSVRow } from './csv-loader.ts';
+
+/**
+ * Tokenize text for BM25 search
+ */
+export function tokenize(text: string): string[] {
+    if (!text) return [];
+
+    const cleaned = String(text)
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ');
+
+    return cleaned
+        .split(/\s+/)
+        .filter(word => word.length > 2);
+}
+
+/**
+ * Join multiple column values into single searchable document
+ */
+export function buildDocument(row: CSVRow, columns: string[]): string {
+    return columns
+        .map(col => row[col] || '')
+        .join(' ');
+}
+
+/**
+ * Extract subset of columns from row object
+ */
+export function extractColumns(row: CSVRow, columns: string[]): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const col of columns) {
+        if (col in row) {
+            result[col] = row[col];
+        }
+    }
+    return result;
+}