@jmruthers/pace-core 0.5.193 → 0.6.1

package/scripts/check-pace-core-compliance.cjs

@@ -385,6 +385,13 @@ function scanFile(filePath, manifest) {
   const content = fs.readFileSync(filePath, 'utf8');
   const relativePath = path.relative(process.cwd(), filePath);
   
+  // Normalize path for cross-platform compatibility (handle both forward and backslash paths)
+  const normalizedPath = relativePath.replace(/\\/g, '/');
+  
+  // Skip Edge Functions - they run in Deno, not React, so React hooks aren't available
+  // Direct Supabase auth calls are the correct approach in Edge Functions
+  const isEdgeFunction = normalizedPath.includes('supabase/functions/');
+  
   // Check for restricted imports
   manifest.restrictedImports.forEach(({ module, reason }) => {
     const importPattern = new RegExp(`from\\s+['"]${module.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`, 'g');
@@ -660,9 +667,15 @@ function scanFile(filePath, manifest) {
   
   // Skip Edge Functions - they run in Deno, not React, so React hooks are not available
   // Edge Functions MUST use direct supabase.auth.getUser() calls - this is correct and required
-  // Handle both forward and backslash paths (Windows vs Unix)
-  const normalizedPath = relativePath.replace(/\\/g, '/');
-  const isEdgeFunction = normalizedPath.includes('supabase/functions/');
+  // isEdgeFunction is already defined above
+  
+  // Other auth patterns - defined here so it's accessible in all scopes
+  const otherAuthPatterns = [
+    { pattern: /\.auth\.signIn\s*\(/g, method: 'signIn' },
+    { pattern: /\.auth\.signUp\s*\(/g, method: 'signUp' },
+    { pattern: /\.auth\.signOut\s*\(/g, method: 'signOut' },
+    { pattern: /\.auth\.onAuthStateChange\s*\(/g, method: 'onAuthStateChange' }
+  ];
   
   // Skip all auth checks for Edge Functions - they cannot use React hooks
   if (isEdgeFunction) {
@@ -684,14 +697,6 @@ function scanFile(filePath, manifest) {
     { pattern: /\w+\.auth\.getSession\s*\(/g, method: 'getSession', specific: false }
   ];
   
-    // Other auth patterns
-    const otherAuthPatterns = [
-      { pattern: /\.auth\.signIn\s*\(/g, method: 'signIn' },
-      { pattern: /\.auth\.signUp\s*\(/g, method: 'signUp' },
-      { pattern: /\.auth\.signOut\s*\(/g, method: 'signOut' },
-      { pattern: /\.auth\.onAuthStateChange\s*\(/g, method: 'onAuthStateChange' }
-    ];
-    
     // Check if file actually uses useUnifiedAuth hook (not just imports it)
     const usesUnifiedAuthHook = /useUnifiedAuth\s*\(/.test(content);
     const hasUnifiedAuthImport = /UnifiedAuthProvider/.test(content) || 
@@ -760,7 +765,8 @@ function scanFile(filePath, manifest) {
       const isInLineComment = /\/\/[^\n]*$/.test(lineUpToMatch);
       
       // Only skip if clearly in a comment - be conservative
-      if (!isInLineComment) {
+      // Also skip Edge Functions - they run in Deno, not React, so React hooks aren't available
+      if (!isInLineComment && !isEdgeFunction) {
         violations.directSupabaseAuth.push({
           file: relativePath,
           line: getLineNumber(content, matchText),
@@ -794,7 +800,8 @@ function scanFile(filePath, manifest) {
       const lineUpToMatch = content.substring(lineStart, searchIndex);
       const isInLineComment = /\/\/[^\n]*$/.test(lineUpToMatch);
       
-      if (!isInLineComment) {
+      // Skip Edge Functions - they run in Deno, not React, so React hooks aren't available
+      if (!isInLineComment && !isEdgeFunction) {
         // Calculate line number from index
         const lineNum = content.substring(0, searchIndex).split('\n').length;
         
@@ -855,7 +862,8 @@ function scanFile(filePath, manifest) {
                         (doubleQuotes % 2 === 1 && beforeMatch.endsWith('"')) ||
                         (backticks % 2 === 1 && beforeMatch.endsWith('`'));
       
-      if (!isInLineComment && !isInBlockComment && !isInString && !usesUnifiedAuthHook) {
+      // Skip Edge Functions - they run in Deno, not React, so React hooks aren't available
+      if (!isInLineComment && !isInBlockComment && !isInString && !usesUnifiedAuthHook && !isEdgeFunction) {
         violations.directSupabaseAuth.push({
           file: relativePath,
           line: getLineNumber(content, matchText),
@@ -2500,6 +2508,10 @@ function findSourceFiles(dir, fileList = []) {
       const stat = fs.statSync(fullPath);
       
       if (stat.isDirectory()) {
+        // Skip Edge Functions directory - they run in Deno, not React, so React hooks aren't available
+        if (item === 'functions' && dir.includes('supabase')) {
+          return; // Skip supabase/functions directory
+        }
         if (!ignoreDirs.includes(item) && !item.startsWith('.')) {
           findSourceFiles(fullPath, fileList);
         }
@@ -2584,5 +2596,12 @@ if (require.main === module) {
   }
 }
 
-module.exports = { main, scanFile, generateReport };
+module.exports = { 
+  main, 
+  scanFile, 
+  generateReport,
+  loadManifest,
+  findProjectRoot,
+  findSourceFiles
+};
 

package/scripts/install-cursor-rules.cjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+/**
+ * Installation Script for pace-core Cursor Rules
+ * @package @jmruthers/pace-core
+ * @module Scripts/install-cursor-rules
+ * 
+ * Copies cursor rules from pace-core to consuming app's .cursor/rules/ directory.
+ * This is an opt-in script - it does NOT run automatically via postinstall.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI color codes for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m'
+};
+
+// Check for safety guards
+function checkSafetyGuards() {
+  // Check environment variable
+  if (process.env.PACE_CURSOR_RULES_DISABLED === '1') {
+    console.log(`${colors.yellow}Skipping cursor rules installation: PACE_CURSOR_RULES_DISABLED=1${colors.reset}`);
+    process.exit(0);
+  }
+  
+  // Check for .git folder (safety guard for CI)
+  const cwd = process.cwd();
+  if (!fs.existsSync(path.join(cwd, '.git'))) {
+    console.log(`${colors.yellow}Skipping cursor rules installation: No .git folder found${colors.reset}`);
+    console.log(`${colors.yellow}This is a safety guard. If you want to install anyway, run with --force${colors.reset}`);
+    if (!process.argv.includes('--force')) {
+      process.exit(0);
+    }
+  }
+}
+
+// Get pace-core package path
+function getPaceCorePath() {
+  // Try to find pace-core in node_modules
+  const cwd = process.cwd();
+  const paceCorePath = path.join(cwd, 'node_modules', '@jmruthers', 'pace-core');
+  
+  if (fs.existsSync(paceCorePath)) {
+    return paceCorePath;
+  }
+  
+  // If not found, try relative to script location (for development)
+  const scriptDir = __dirname;
+  const relativePath = path.join(scriptDir, '..');
+  if (fs.existsSync(path.join(relativePath, 'cursor-rules'))) {
+    return relativePath;
+  }
+  
+  console.error(`${colors.red}Error: Could not find @jmruthers/pace-core package${colors.reset}`);
+  console.error(`${colors.red}Make sure pace-core is installed: npm install @jmruthers/pace-core${colors.reset}`);
+  process.exit(1);
+}
+
+// Get cursor rules source directory
+function getCursorRulesSource(paceCorePath) {
+  const rulesPath = path.join(paceCorePath, 'cursor-rules');
+  if (!fs.existsSync(rulesPath)) {
+    console.error(`${colors.red}Error: cursor-rules directory not found in pace-core${colors.reset}`);
+    process.exit(1);
+  }
+  return rulesPath;
+}
+
+// Get target directory (.cursor/rules in app root)
+function getCursorRulesTarget() {
+  const cwd = process.cwd();
+  const targetDir = path.join(cwd, '.cursor', 'rules');
+  return targetDir;
+}
+
+// Read rule file and extract version metadata
+function getRuleVersion(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const frontmatter = frontmatterMatch[1];
+      const versionMatch = frontmatter.match(/paceCoreVersion:\s*["']?([^"'\n]+)["']?/);
+      const rulesVersionMatch = frontmatter.match(/rulesVersion:\s*["']?([^"'\n]+)["']?/);
+      return {
+        paceCoreVersion: versionMatch ? versionMatch[1] : null,
+        rulesVersion: rulesVersionMatch ? rulesVersionMatch[1] : null
+      };
+    }
+  } catch (error) {
+    // Ignore errors
+  }
+  return { paceCoreVersion: null, rulesVersion: null };
+}
+
+// Check if file needs updating
+function needsUpdate(sourcePath, targetPath, force) {
+  if (force) {
+    return true;
+  }
+  
+  if (!fs.existsSync(targetPath)) {
+    return true;
+  }
+  
+  // Compare versions first (fast check)
+  const sourceVersion = getRuleVersion(sourcePath);
+  const targetVersion = getRuleVersion(targetPath);
+  
+  // If versions differ, needs update
+  if (sourceVersion.paceCoreVersion !== targetVersion.paceCoreVersion ||
+      sourceVersion.rulesVersion !== targetVersion.rulesVersion) {
+    return true;
+  }
+  
+  // If versions match but content differs, also needs update
+  // (handles cases where version metadata wasn't updated)
+  try {
+    const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+    const targetContent = fs.readFileSync(targetPath, 'utf8');
+    if (sourceContent !== targetContent) {
+      return true;
+    }
+  } catch (error) {
+    // If we can't read files, assume update needed
+    return true;
+  }
+  
+  return false;
+}
+
+// Install cursor rules
+function installCursorRules(force = false) {
+  checkSafetyGuards();
+  
+  const paceCorePath = getPaceCorePath();
+  const sourceDir = getCursorRulesSource(paceCorePath);
+  const targetDir = getCursorRulesTarget();
+  
+  // Create target directory if it doesn't exist
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    console.log(`${colors.green}Created .cursor/rules/ directory${colors.reset}`);
+  }
+  
+  // Read all .mdc files from source
+  const files = fs.readdirSync(sourceDir)
+    .filter(file => file.endsWith('.mdc'))
+    .sort(); // Sort for consistent output
+  
+  if (files.length === 0) {
+    console.log(`${colors.yellow}No cursor rules found in pace-core${colors.reset}`);
+    return;
+  }
+  
+  console.log(`${colors.cyan}Installing cursor rules from pace-core...${colors.reset}\n`);
+  
+  let installed = 0;
+  let skipped = 0;
+  let updated = 0;
+  
+  files.forEach(file => {
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    
+    // Check if this is a pace-core rule (00-09) or app rule (50+)
+    const ruleNumber = parseInt(file.match(/^(\d+)-/)?.[1] || '99');
+    const isPaceCoreRule = ruleNumber >= 0 && ruleNumber <= 9;
+    
+    if (fs.existsSync(targetPath)) {
+      if (isPaceCoreRule) {
+        // pace-core rules should be automatically updated when they change
+        if (needsUpdate(sourcePath, targetPath, force)) {
+          // Automatically update pace-core rules when versions differ or content changed
+          fs.copyFileSync(sourcePath, targetPath);
+          console.log(`${colors.green}✓${colors.reset} Updated ${file}${force ? ' (forced)' : ''}`);
+          updated++;
+        } else {
+          console.log(`${colors.blue}○${colors.reset} ${file} is up to date`);
+          skipped++;
+        }
+      } else {
+        // App rules (50+) are never overwritten
+        console.log(`${colors.blue}○${colors.reset} ${file} is a custom rule, skipping`);
+        skipped++;
+      }
+    } else {
+      // File doesn't exist, install it
+      fs.copyFileSync(sourcePath, targetPath);
+      console.log(`${colors.green}✓${colors.reset} Installed ${file}`);
+      installed++;
+    }
+  });
+  
+  console.log(`\n${colors.bold}Installation Summary:${colors.reset}`);
+  console.log(`  ${colors.green}Installed:${colors.reset} ${installed}`);
+  console.log(`  ${colors.yellow}Updated:${colors.reset} ${updated}`);
+  console.log(`  ${colors.blue}Skipped:${colors.reset} ${skipped}`);
+  console.log(`\n${colors.cyan}Cursor rules are now available in .cursor/rules/${colors.reset}`);
+  console.log(`${colors.cyan}Restart Cursor to load the new rules.${colors.reset}`);
+}
+
+// Main execution
+function main() {
+  const force = process.argv.includes('--force');
+  
+  if (force) {
+    console.log(`${colors.yellow}Warning: --force flag is set. This will overwrite existing pace-core rules.${colors.reset}\n`);
+  }
+  
+  try {
+    installCursorRules(force);
+  } catch (error) {
+    console.error(`${colors.red}Error installing cursor rules:${colors.reset}`);
+    console.error(error.message);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { installCursorRules, getCursorRulesTarget };

package/src/__tests__/helpers/test-providers.tsx

@@ -246,7 +246,7 @@ interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
 }
 
 export function renderWithProviders(
-  ui: React.ReactElement,
+  ui: React.ReactElement<any>,
   options: CustomRenderOptions = {}
 ) {
   const {

package/src/__tests__/helpers/test-utils.tsx

@@ -48,7 +48,7 @@ interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
 }
 
 export function renderWithProviders(
-  ui: ReactElement,
+  ui: ReactElement<any>,
   options: CustomRenderOptions = {}
 ): ReturnType<typeof render> {
   const {

package/src/components/Badge/Badge.tsx

@@ -251,8 +251,7 @@ function getBadgeClasses(variant: BadgeVariant = 'solid-main-normal'): string {
  * <Badge variant="soft-acc-strong">Featured</Badge>
  * ```
  */
-const Badge = React.forwardRef<HTMLSpanElement, BadgeProps>(
-  ({ className, variant = 'solid-main-normal', ...props }, ref) => {
+function Badge({ className, variant = 'solid-main-normal', ref, ...props }: BadgeProps & { ref?: React.Ref<HTMLSpanElement> }) {
     const isSoftVariant = variant.startsWith('soft-');
     
     if (isSoftVariant) {
@@ -291,8 +290,7 @@ const Badge = React.forwardRef<HTMLSpanElement, BadgeProps>(
         {...props}
       />
     );
-  }
-);
+}
 
 Badge.displayName = 'Badge';
 

package/src/components/Button/Button.tsx

@@ -198,11 +198,12 @@ export function ButtonGroup({
           // Type assertion needed because React.ComponentType doesn't guarantee displayName
           const componentType = child.type as React.ComponentType<unknown> & { displayName?: string };
           if (componentType.displayName === 'Button') {
+            const childProps = child.props as { variant?: string; size?: string; [key: string]: unknown };
             return React.cloneElement(child, {
-              variant: child.props.variant || variant,
-              size: child.props.size || size,
-              ...child.props
-            });
+              variant: childProps.variant || variant,
+              size: childProps.size || size,
+              ...childProps
+            } as typeof childProps);
           }
         }
         return child;

package/src/components/Calendar/Calendar.tsx

@@ -350,7 +350,7 @@ const Calendar = React.forwardRef<HTMLTableElement, CalendarProps>(
                 goToMonth(nextMonth);
               };
               
-              const monthGridElement = monthGridChild as React.ReactElement & {
+              const monthGridElement = monthGridChild as React.ReactElement<any> & {
                 ref?: React.Ref<HTMLTableElement | null>;
               };
               const mergedRef =