scc-universal 1.1.0

package/scripts/hooks/post-edit-console-warn.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Hook: Warn about console.log statements after edits
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs after Edit tool use. If the edited JS/TS file (especially LWC)
+ * contains console.log statements, warns with line numbers to help
+ * remove debug statements before committing.
+ */
+
+const fs = require('fs');
+
+const MAX_STDIN = 1024 * 1024; // 1MB limit
+let data = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(data);
+    const filePath = input.tool_input?.file_path;
+
+    if (filePath && /\.(ts|tsx|js|jsx)$/.test(filePath)) {
+      let content;
+      try {
+        content = fs.readFileSync(filePath, 'utf8');
+      } catch {
+        process.stdout.write(data);
+        process.exit(0);
+      }
+
+      if (!content) { process.stdout.write(data); process.exit(0); }
+      const lines = content.split('\n');
+      const matches = [];
+
+      lines.forEach((line, idx) => {
+        if (/console\.log/.test(line)) {
+          matches.push((idx + 1) + ': ' + line.trim());
+        }
+      });
+
+      if (matches.length > 0) {
+        console.error('[Hook] WARNING: console.log found in ' + filePath);
+        matches.slice(0, 5).forEach(m => console.error(m));
+        console.error('[Hook] Remove console.log before committing');
+      }
+    }
+  } catch {
+    // Invalid input — pass through
+  }
+
+  process.stdout.write(data);
+  process.exit(0);
+});

package/scripts/hooks/post-edit-format.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Post-Edit Format Hook
+ *
+ * Auto-formats files after edits using Prettier or sfdx-scanner.
+ * Runs on PostToolUse for Edit operations.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MAX_STDIN = 1024 * 1024;
+
+function log(msg) {
+  process.stderr.write(`${msg}\n`);
+}
+
+function tryFormat(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return;
+
+  filePath = path.resolve(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+
+  // JavaScript/TypeScript/JSON/HTML/CSS — try Prettier
+  if (['.js', '.ts', '.jsx', '.tsx', '.json', '.html', '.css'].includes(ext)) {
+    const result = spawnSync('npx', ['prettier', '--write', filePath], {
+      encoding: 'utf8',
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result.status === 0) {
+      log(`[SCC Format] Formatted ${path.basename(filePath)} with Prettier`);
+    }
+    return;
+  }
+
+  // Apex — try Prettier with apex plugin
+  if (ext === '.cls' || ext === '.trigger') {
+    const result = spawnSync('npx', ['prettier', '--write', '--plugin', 'prettier-plugin-apex', filePath], {
+      encoding: 'utf8',
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result.status === 0) {
+      log(`[SCC Format] Formatted ${path.basename(filePath)} with Prettier (Apex)`);
+    }
+    return;
+  }
+}
+
+function run(rawInput) {
+  try {
+    const input = JSON.parse(rawInput);
+    const filePath = String(input.tool_input?.file_path || '');
+    tryFormat(filePath);
+  } catch {
+    // Ignore errors
+  }
+  return rawInput;
+}
+
+if (require.main === module) {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      raw += chunk.substring(0, MAX_STDIN - raw.length);
+    }
+  });
+  process.stdin.on('end', () => {
+    const result = run(raw);
+    process.stdout.write(result);
+  });
+}
+
+module.exports = { run };

package/scripts/hooks/post-edit-typecheck.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/**
+ * Post-Edit Type Check Hook
+ *
+ * Runs type checking after editing TypeScript or LWC files.
+ * For LWC: validates component structure.
+ * For TS: runs tsc --noEmit on the file.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MAX_STDIN = 1024 * 1024;
+
+function log(msg) {
+  process.stderr.write(`${msg}\n`);
+}
+
+function checkFile(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return;
+
+  filePath = path.resolve(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+
+  // TypeScript files — run tsc
+  if (ext === '.ts' || ext === '.tsx') {
+    const result = spawnSync('npx', ['tsc', '--noEmit', '--pretty', filePath], {
+      encoding: 'utf8',
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0 && result.stderr) {
+      log(`[SCC TypeCheck] Type errors in ${path.basename(filePath)}:`);
+      const lines = result.stderr.split('\n').slice(0, 5);
+      for (const line of lines) {
+        if (line.trim()) log(`  ${line}`);
+      }
+    }
+    return;
+  }
+
+  // LWC JavaScript — validate basic structure
+  if (ext === '.js' && filePath.includes('/lwc/')) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const issues = [];
+
+      // Check for default export
+      if (!content.includes('export default class')) {
+        issues.push('Missing default class export — LWC requires `export default class`');
+      }
+
+      // Check for LightningElement extension
+      if (content.includes('export default class') && !content.includes('LightningElement')) {
+        issues.push('LWC class should extend LightningElement');
+      }
+
+      if (issues.length > 0) {
+        log(`[SCC TypeCheck] LWC issues in ${path.basename(filePath)}:`);
+        for (const issue of issues) {
+          log(`  - ${issue}`);
+        }
+      }
+    } catch {
+      // Ignore read errors
+    }
+  }
+}
+
+function run(rawInput) {
+  try {
+    const input = JSON.parse(rawInput);
+    const filePath = String(input.tool_input?.file_path || '');
+    checkFile(filePath);
+  } catch {
+    // Ignore parse errors
+  }
+  return rawInput;
+}
+
+if (require.main === module) {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      raw += chunk.substring(0, MAX_STDIN - raw.length);
+    }
+  });
+  process.stdin.on('end', () => {
+    const result = run(raw);
+    process.stdout.write(result);
+  });
+}
+
+module.exports = { run };

package/scripts/hooks/post-write.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * post-write.js — PostToolUse hook for Write operations.
+ *
+ * Detects Salesforce-specific file writes and provides guidance:
+ *   - .cls / .trigger files → remind about 75% Apex test coverage
+ *   - LWC .js files → remind about Jest unit tests
+ *   - .page, .component (Visualforce) → note about test considerations
+ */
+
+const path = require('path');
+const readline = require('readline');
+
+/**
+ * Classify a written file path into Salesforce content type.
+ */
+function classifyFile(filePath) {
+  if (!filePath) return null;
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  const parts = filePath.split(path.sep);
+
+  // Apex class
+  if (ext === '.cls') return 'apex-class';
+  // Apex trigger
+  if (ext === '.trigger') return 'apex-trigger';
+  // Apex test class (may already have test annotations but remind anyway)
+  if (ext === '.cls' && base.includes('test')) return 'apex-test';
+
+  // LWC: check if the file is inside an lwc directory
+  const lwcIdx = parts.findIndex(p => p === 'lwc');
+  if (lwcIdx !== -1) {
+    if (ext === '.js' && !base.endsWith('.test.js') && !base.endsWith('.spec.js')) return 'lwc-js';
+    if (ext === '.html') return 'lwc-html';
+    if (ext === '.css') return 'lwc-css';
+    if (ext === '.js' && (base.endsWith('.test.js') || base.endsWith('.spec.js'))) return 'lwc-test';
+  }
+
+  // Aura component
+  const auraIdx = parts.findIndex(p => p === 'aura');
+  if (auraIdx !== -1 && ext === '.js') return 'aura-js';
+
+  // Visualforce
+  if (ext === '.page') return 'visualforce-page';
+  if (ext === '.component') return 'visualforce-component';
+
+  // Flow
+  if (ext === '.flow' || ext === '.flow-meta.xml') return 'flow';
+
+  // Permission set / profile
+  if (filePath.includes('permissionsets') || ext === '.permissionset-meta.xml') return 'permission-set';
+
+  return null;
+}
+
+const REMINDERS = {
+  'apex-class': {
+    emoji: '',
+    title: 'Apex Class Written',
+    messages: [
+      'Apex classes require 75% code coverage across your org to deploy to production.',
+      'Create or update a corresponding test class (e.g., MyClass_Test.cls or MyClassTest.cls).',
+      'Use @isTest annotation and System.assert/assertEquals for assertions.',
+      'Run tests: sf apex run test --class-names MyClassTest --result-format human',
+    ],
+  },
+  'apex-trigger': {
+    emoji: '',
+    title: 'Apex Trigger Written',
+    messages: [
+      'Triggers require 75% code coverage to deploy to production.',
+      'Best practice: keep trigger logic minimal — delegate to a handler class.',
+      'Create a test class that fires the trigger with both insert and update scenarios.',
+      'Consider using a TriggerHandler framework for maintainability.',
+      'Run tests: sf apex run test --class-names MyTriggerTest --result-format human',
+    ],
+  },
+  'lwc-js': {
+    emoji: '',
+    title: 'LWC JavaScript Written',
+    messages: [
+      'LWC components should have Jest unit tests.',
+      'Test file convention: __tests__/myComponent.test.js',
+      'Run Jest tests: npm run test:unit (or sf lightning generate component for scaffolding)',
+      'Use @salesforce/lwc-jest or @lwc/jest-transformer for testing.',
+      'Mock Salesforce imports with jest.mock() or @salesforce/jest-mocks.',
+    ],
+  },
+  'lwc-html': {
+    emoji: '',
+    title: 'LWC Template Written',
+    messages: [
+      'Update Jest tests if you added new elements, slots, or event handlers.',
+      'Validate template with: sf project deploy start --dry-run',
+    ],
+  },
+  'aura-js': {
+    emoji: '',
+    title: 'Aura Component Written',
+    messages: [
+      'Consider migrating Aura components to LWC for better performance and maintainability.',
+      'Aura components can coexist with LWC but LWC is the recommended approach for new development.',
+    ],
+  },
+  'visualforce-page': {
+    emoji: '',
+    title: 'Visualforce Page Written',
+    messages: [
+      'Visualforce pages used with Apex controllers require controller test coverage.',
+      'Consider whether this functionality could be implemented with LWC instead.',
+    ],
+  },
+  'flow': {
+    emoji: '',
+    title: 'Flow Metadata Written',
+    messages: [
+      'Test Flows using Flow Interview tests in Apex or through the UI.',
+      'Ensure Flow is activated before deploying to production.',
+    ],
+  },
+};
+
+function generateReminder(fileType, filePath) {
+  const reminder = REMINDERS[fileType];
+  if (!reminder) return null;
+
+  const lines = [];
+  lines.push(`[SCC] ${reminder.title}: ${path.basename(filePath)}`);
+  for (const msg of reminder.messages) {
+    lines.push(`  • ${msg}`);
+  }
+  return lines.join('\n');
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+let rawInput = '';
+const rl = readline.createInterface({ input: process.stdin });
+rl.on('line', line => { rawInput += line + '\n'; });
+
+rl.on('close', () => {
+  let input = {};
+  try {
+    input = JSON.parse(rawInput.trim() || '{}');
+  } catch {
+    process.exit(0);
+  }
+
+  // Only process Write tool
+  if (input.tool_name !== 'Write' && input.tool_name !== 'write') {
+    process.exit(0);
+  }
+
+  const filePath = (input.tool_input && input.tool_input.file_path) || '';
+  if (!filePath) process.exit(0);
+
+  const fileType = classifyFile(filePath);
+  if (!fileType) process.exit(0);
+
+  const reminder = generateReminder(fileType, filePath);
+  if (reminder) {
+    console.log('\n' + reminder + '\n');
+  }
+
+  process.exit(0);
+});

package/scripts/hooks/pre-bash-git-push-reminder.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * PreToolUse Hook: Remind to review changes before git push
+ *
+ * Detects `git push` commands and logs a reminder to review
+ * changes before pushing.
+ */
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  if (raw.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - raw.length;
+    raw += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(raw);
+    const cmd = String(input.tool_input?.command || '');
+    if (/\bgit\s+push\b/.test(cmd)) {
+      console.error('[Hook] Review changes before push...');
+      console.error('[Hook] Continuing with push (remove this hook to add interactive review)');
+    }
+  } catch {
+    // ignore parse errors and pass through
+  }
+
+  process.stdout.write(raw);
+});

package/scripts/hooks/pre-bash-tmux-reminder.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * pre-bash-tmux-reminder.js — PreToolUse (Bash) hook.
+ *
+ * Reminds the user to run long-running Salesforce CLI commands inside tmux
+ * so that session disconnection doesn't kill deploys or test runs.
+ *
+ * Fires on: sf project deploy, sfdx force:source:deploy, sf apex run test,
+ *           sfdx force:apex:test:run, sf org create scratch, npm test, jest
+ *
+ * Profile: strict (only fires when SCC_HOOK_PROFILE=strict)
+ * Wired via run-with-flags.js — gating is handled externally.
+ */
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  if (raw.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - raw.length;
+    raw += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(raw);
+    const cmd = String(input.tool_input?.command || '');
+
+    if (
+      process.platform !== 'win32' &&
+      !process.env.TMUX &&
+      /\b(sf project deploy|sfdx force:source:deploy|sfdx force:mdapi:deploy|sf apex run test|sfdx force:apex:test:run|sf org create scratch|sfdx force:org:create|npm test\b|jest\b)/.test(cmd)
+    ) {
+      console.error('[SCC] Long-running Salesforce command detected. Consider running in tmux:');
+      console.error('[SCC]   tmux new -s sf-dev  |  tmux attach -t sf-dev');
+      console.error('[SCC] This prevents session disconnection from killing deploys or test runs.');
+    }
+  } catch {
+    // ignore parse errors and pass through
+  }
+
+  process.stdout.write(raw);
+});

package/scripts/hooks/pre-compact.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook — Save state before context compaction.
+ *
+ * Logs compaction events and annotates active session files
+ * so post-compaction context has a record of what happened.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('../lib/utils');
+
+function getClaudeDir() {
+  return path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.claude');
+}
+
+function getDateTimeString() {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19);
+}
+
+async function main() {
+  const sessionsDir = path.join(getClaudeDir(), 'sessions');
+  const compactionLog = path.join(sessionsDir, 'compaction-log.txt');
+
+  ensureDir(sessionsDir);
+
+  const timestamp = getDateTimeString();
+  fs.appendFileSync(compactionLog, `[${timestamp}] Context compaction triggered\n`);
+
+  // Annotate active session files
+  try {
+    const entries = fs.readdirSync(sessionsDir);
+    const sessionFiles = entries.filter(f => f.endsWith('-session.tmp'));
+    if (sessionFiles.length > 0) {
+      const activeSession = path.join(sessionsDir, sessionFiles[0]);
+      fs.appendFileSync(activeSession, `\n---\n**[Compaction at ${timestamp}]** — Context was summarized\n`);
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  process.stderr.write('[SCC PreCompact] State saved before compaction\n');
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[SCC PreCompact] Error:', err.message);
+  process.exit(0);
+});