feat: add Cascade CLI integration for auto-fix and performance refactoring in pre-commit hook

Author: Umutcan ÖNER

.husky/pre-commit

@@ -49,4 +49,22 @@ if [ $? -ne 0 ]; then
   exit 1
 fi
 
+# Run Cascade auto-fix and refactor
+echo "🔧 Running Cascade auto-fix and refactor..."
+
+# Check if Cascade CLI is available
+if ! command -v cascade &> /dev/null; then
+  echo "${YELLOW}⚠️  Cascade CLI not found. Skipping auto-fix and refactor.${NC}"
+else
+  # Run biome check first if available and create output
+  if command -v biome &> /dev/null; then
+    biome check . --json > biome.json 2>/dev/null || true
+    node ./scripts/cascade-fix.js --from=biome.json --apply
+    rm biome.json 2>/dev/null || true
+  fi
+  
+  # Run refactor script for performance optimizations
+  node ./scripts/cascade-refactor.js --strategy=performance --apply
+fi
+
 echo "${GREEN}✅ Pre-commit checks passed!${NC}"

scripts/cascade-fix.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * SPDX-License-Identifier: MIT
+ *
+ * Auto refactor script for Windsurf Cascade integration.
+ * Supports input from Biome, TypeScript, or custom static analyzers.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const args = process.argv.slice(2);
+const options = {
+  apply: args.includes('--apply'),
+  dry: args.includes('--dry'),
+  input: getArgValue('--from') || 'typecheck.json', // default
+};
+
+// Helper to get CLI argument value
+function getArgValue(flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+
+// Helper: check if cascade CLI is available
+function checkCascade() {
+  try {
+    const result = spawnSync('cascade', ['--version'], { encoding: 'utf-8' });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// Helper: run Cascade prompt on code block
+function runCascadePrompt({ filePath, line, message }) {
+  const prompt = `Refactor the following code to fix this issue:\n\n// ${message}\n`;
+
+  const fileContent = fs.readFileSync(filePath, 'utf-8').split('\n');
+  const context = fileContent.slice(Math.max(0, line - 5), line + 5).join('\n');
+
+  const fullPrompt = `${prompt}\n\`\`\`ts\n${context}\n\`\`\``;
+
+  const result = spawnSync(
+    'cascade',
+    ['--prompt', fullPrompt, '--file', filePath, '--line', String(line)],
+    { encoding: 'utf-8' }
+  );
+
+  return result.stdout;
+}
+
+// Main logic
+function run() {
+  if (!fs.existsSync(options.input)) {
+    console.error(`❌ Cannot find file: ${options.input}`);
+    process.exit(1);
+  }
+
+  const raw = fs.readFileSync(options.input, 'utf-8');
+  let issues = [];
+
+  try {
+    issues = JSON.parse(raw);
+  } catch {
+    console.error('❌ Invalid JSON input file.');
+    process.exit(1);
+  }
+
+  const applicable = issues.filter((i) => i.file && i.message && i.line);
+  if (applicable.length === 0) {
+    console.log('✅ No fixable issues found.');
+    return;
+  }
+
+  const cascadeAvailable = checkCascade();
+  if (!cascadeAvailable) {
+    console.warn('⚠️ Cascade CLI not found. Skipping auto fix.');
+  }
+
+  for (const issue of applicable) {
+    const filePath = path.resolve(issue.file);
+    const message = issue.message;
+    const line = issue.line;
+
+    console.log(`🔧 Refactoring ${filePath}:${line} - ${message}`);
+
+    if (options.dry || !options.apply || !cascadeAvailable) {
+      console.log(`📝 Suggested fix: [${message}]`);
+      continue;
+    }
+
+    const result = runCascadePrompt({ filePath, line, message });
+    console.log(result.trim());
+  }
+
+  console.log(`✨ Done. ${options.apply ? 'Fixes applied.' : 'Dry run.'}`);
+}
+
+run();

scripts/cascade-refactor.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * SPDX-License-Identifier: MIT
+ *
+ * Proactive performance-based refactor tool using Cascade CLI.
+ * Scans entire repo by default, or limited via --include=path
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const glob = require('fast-glob');
+const { spawnSync } = require('node:child_process');
+
+// ----------------------------
+// CLI Options
+// ----------------------------
+const args = process.argv.slice(2);
+const targetDir = getArgValue('--include') || '.'; // scan entire repo by default
+const strategy = getArgValue('--strategy') || 'performance';
+const shouldApply = args.includes('--apply');
+const shouldDry = args.includes('--dry');
+
+function getArgValue(flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 && args[i + 1] ? args[i + 1] : null;
+}
+
+function checkCascade() {
+  try {
+    const result = spawnSync('cascade', ['--version'], { encoding: 'utf-8' });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// ----------------------------
+// Pattern matchers (basic)
+// ----------------------------
+function findSuspiciousLines(content) {
+  const lines = content.split('\n');
+  const matches = [];
+
+  lines.forEach((line, i) => {
+    if (line.includes('.map(') && (line.includes('.filter(') || line.includes('.reduce('))) {
+      matches.push({ line: i + 1, content: line.trim() });
+    }
+
+    if (line.match(/for\s*\(\s*let\s+[a-z]+\s*=\s*0;/)) {
+      matches.push({ line: i + 1, content: line.trim() });
+    }
+  });
+
+  return matches;
+}
+
+function runCascade({ filePath, line, codeBlock }) {
+  const prompt = `Refactor the following code to optimize runtime performance.
+Avoid redundant array operations or nested loops.
+Ensure the logic remains the same and behavior is preserved.
+
+\`\`\`ts
+${codeBlock}
+\`\`\`
+`;
+
+  const result = spawnSync(
+    'cascade',
+    ['--prompt', prompt, '--file', filePath, '--line', String(line)],
+    { encoding: 'utf-8' }
+  );
+
+  return result.stdout;
+}
+
+// ----------------------------
+// Main
+// ----------------------------
+async function run() {
+  const cascadeAvailable = checkCascade();
+  if (!cascadeAvailable) {
+    console.error('❌ Cascade CLI not found.');
+    process.exit(1);
+  }
+
+  const files = await glob([`${targetDir}/**/*.ts`, `${targetDir}/**/*.tsx`], {
+    ignore: [
+      '**/node_modules/**',
+      '**/.next/**',
+      '**/dist/**',
+      '**/.turbo/**',
+      '**/.git/**',
+      '**/build/**',
+      '**/out/**',
+      '**/coverage/**',
+    ],
+  });
+
+  for (const file of files) {
+    const fullPath = path.resolve(file);
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    const suspicious = findSuspiciousLines(content);
+
+    if (suspicious.length === 0) continue;
+
+    console.log(`🔍 Found ${suspicious.length} performance candidate(s) in ${file}`);
+
+    for (const match of suspicious) {
+      const { line, content: codeLine } = match;
+      console.log(`⚡ Refactoring ${file}:${line}`);
+
+      if (shouldDry) {
+        console.log(`📝 Suspicious code: ${codeLine}`);
+        continue;
+      }
+
+      if (shouldApply) {
+        const result = runCascade({
+          filePath: fullPath,
+          line,
+          codeBlock: codeLine,
+        });
+
+        console.log(result.trim());
+      }
+    }
+  }
+
+  console.log('✅ Cascade performance refactor complete.');
+}
+
+run();