scc-universal 1.1.0

package/scripts/hooks/session-end.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Stop Hook (Session End) - Persist learnings during active sessions
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs on Stop events (after each response). Extracts a meaningful summary
+ * from the session transcript (via stdin JSON transcript_path) and updates a
+ * session file for cross-session continuity.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const SUMMARY_START_MARKER = '<!-- SCC:SUMMARY:START -->';
+const SUMMARY_END_MARKER = '<!-- SCC:SUMMARY:END -->';
+const SESSION_SEPARATOR = '\n---\n';
+
+function getSessionsDir() {
+  return path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'sessions');
+}
+
+function getDateString() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+function getTimeString() {
+  const d = new Date();
+  return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+}
+
+function getSessionIdShort() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+function getProjectName() {
+  try {
+    return path.basename(process.cwd());
+  } catch {
+    return 'unknown';
+  }
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function writeFile(filePath, content) {
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+function runCommand(cmd) {
+  try {
+    const { execSync } = require('child_process');
+    const output = execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    return { success: true, output };
+  } catch {
+    return { success: false, output: '' };
+  }
+}
+
+function log(msg) {
+  console.error(msg);
+}
+
+/**
+ * Extract a meaningful summary from the session transcript.
+ */
+function extractSessionSummary(transcriptPath) {
+  const content = readFile(transcriptPath);
+  if (!content) return null;
+
+  const lines = content.split('\n').filter(Boolean);
+  const userMessages = [];
+  const toolsUsed = new Set();
+  const filesModified = new Set();
+  let parseErrors = 0;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      if (entry.type === 'user' || entry.role === 'user' || entry.message?.role === 'user') {
+        const rawContent = entry.message?.content ?? entry.content;
+        const text = typeof rawContent === 'string'
+          ? rawContent
+          : Array.isArray(rawContent)
+            ? rawContent.map(c => (c && c.text) || '').join(' ')
+            : '';
+        if (text.trim()) {
+          userMessages.push(text.trim().slice(0, 200));
+        }
+      }
+
+      if (entry.type === 'tool_use' || entry.tool_name) {
+        const toolName = entry.tool_name || entry.name || '';
+        if (toolName) toolsUsed.add(toolName);
+        const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
+        if (filePath && (toolName === 'Edit' || toolName === 'Write')) {
+          filesModified.add(filePath);
+        }
+      }
+
+      if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+        for (const block of entry.message.content) {
+          if (block.type === 'tool_use') {
+            const toolName = block.name || '';
+            if (toolName) toolsUsed.add(toolName);
+            const filePath = block.input?.file_path || '';
+            if (filePath && (toolName === 'Edit' || toolName === 'Write')) {
+              filesModified.add(filePath);
+            }
+          }
+        }
+      }
+    } catch {
+      parseErrors++;
+    }
+  }
+
+  if (parseErrors > 0) {
+    log(`[SessionEnd] Skipped ${parseErrors}/${lines.length} unparseable transcript lines`);
+  }
+
+  if (userMessages.length === 0) return null;
+
+  return {
+    userMessages: userMessages.slice(-10),
+    toolsUsed: Array.from(toolsUsed).slice(0, 20),
+    filesModified: Array.from(filesModified).slice(0, 30),
+    totalMessages: userMessages.length
+  };
+}
+
+// Read hook input from stdin
+const MAX_STDIN = 1024 * 1024;
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (stdinData.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - stdinData.length;
+    stdinData += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  runMain();
+});
+
+function runMain() {
+  main().catch(err => {
+    console.error('[SessionEnd] Error:', err.message);
+    process.exit(0);
+  });
+}
+
+function getSessionMetadata() {
+  const branchResult = runCommand('git rev-parse --abbrev-ref HEAD');
+  return {
+    project: getProjectName() || 'unknown',
+    branch: branchResult.success ? branchResult.output : 'unknown',
+    worktree: process.cwd()
+  };
+}
+
+function extractHeaderField(header, label) {
+  const match = header.match(new RegExp(`\\*\\*${escapeRegExp(label)}:\\*\\*\\s*(.+)$`, 'm'));
+  return match ? match[1].trim() : null;
+}
+
+function buildSessionHeader(today, currentTime, metadata, existingContent = '') {
+  const headingMatch = existingContent.match(/^#\s+.+$/m);
+  const heading = headingMatch ? headingMatch[0] : `# Session: ${today}`;
+  const date = extractHeaderField(existingContent, 'Date') || today;
+  const started = extractHeaderField(existingContent, 'Started') || currentTime;
+
+  return [
+    heading,
+    `**Date:** ${date}`,
+    `**Started:** ${started}`,
+    `**Last Updated:** ${currentTime}`,
+    `**Project:** ${metadata.project}`,
+    `**Branch:** ${metadata.branch}`,
+    `**Worktree:** ${metadata.worktree}`,
+    ''
+  ].join('\n');
+}
+
+function mergeSessionHeader(content, today, currentTime, metadata) {
+  const separatorIndex = content.indexOf(SESSION_SEPARATOR);
+  if (separatorIndex === -1) return null;
+  const existingHeader = content.slice(0, separatorIndex);
+  const body = content.slice(separatorIndex + SESSION_SEPARATOR.length);
+  const nextHeader = buildSessionHeader(today, currentTime, metadata, existingHeader);
+  return `${nextHeader}${SESSION_SEPARATOR}${body}`;
+}
+
+async function main() {
+  let transcriptPath;
+  try {
+    const input = JSON.parse(stdinData);
+    transcriptPath = input.transcript_path;
+  } catch {
+    transcriptPath = process.env.CLAUDE_TRANSCRIPT_PATH;
+  }
+
+  const sessionsDir = getSessionsDir();
+  const today = getDateString();
+  const shortId = getSessionIdShort();
+  const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
+  const sessionMetadata = getSessionMetadata();
+
+  ensureDir(sessionsDir);
+
+  const currentTime = getTimeString();
+
+  let summary = null;
+  if (transcriptPath) {
+    if (fs.existsSync(transcriptPath)) {
+      summary = extractSessionSummary(transcriptPath);
+    } else {
+      log(`[SessionEnd] Transcript not found: ${transcriptPath}`);
+    }
+  }
+
+  if (fs.existsSync(sessionFile)) {
+    const existing = readFile(sessionFile);
+    let updatedContent = existing;
+
+    if (existing) {
+      const merged = mergeSessionHeader(existing, today, currentTime, sessionMetadata);
+      if (merged) {
+        updatedContent = merged;
+      }
+    }
+
+    if (summary && updatedContent) {
+      const summaryBlock = buildSummaryBlock(summary);
+      if (updatedContent.includes(SUMMARY_START_MARKER) && updatedContent.includes(SUMMARY_END_MARKER)) {
+        updatedContent = updatedContent.replace(
+          new RegExp(`${escapeRegExp(SUMMARY_START_MARKER)}[\\s\\S]*?${escapeRegExp(SUMMARY_END_MARKER)}`),
+          summaryBlock
+        );
+      } else {
+        updatedContent = updatedContent.replace(
+          /## (?:Session Summary|Current State)[\s\S]*?$/,
+          `${summaryBlock}\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\`\n`
+        );
+      }
+    }
+
+    if (updatedContent) {
+      writeFile(sessionFile, updatedContent);
+    }
+
+    log(`[SessionEnd] Updated session file: ${sessionFile}`);
+  } else {
+    const summarySection = summary
+      ? `${buildSummaryBlock(summary)}\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\``
+      : `## Current State\n\n[Session context goes here]\n\n### Completed\n- [ ]\n\n### In Progress\n- [ ]\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\``;
+
+    const template = `${buildSessionHeader(today, currentTime, sessionMetadata)}${SESSION_SEPARATOR}${summarySection}\n`;
+    writeFile(sessionFile, template);
+    log(`[SessionEnd] Created session file: ${sessionFile}`);
+  }
+
+  process.exit(0);
+}
+
+function buildSummarySection(summary) {
+  let section = '## Session Summary\n\n';
+
+  section += '### Tasks\n';
+  for (const msg of summary.userMessages) {
+    section += `- ${msg.replace(/\n/g, ' ').replace(/`/g, '\\`')}\n`;
+  }
+  section += '\n';
+
+  if (summary.filesModified.length > 0) {
+    section += '### Files Modified\n';
+    for (const f of summary.filesModified) {
+      section += `- ${f}\n`;
+    }
+    section += '\n';
+  }
+
+  if (summary.toolsUsed.length > 0) {
+    section += `### Tools Used\n${summary.toolsUsed.join(', ')}\n\n`;
+  }
+
+  section += `### Stats\n- Total user messages: ${summary.totalMessages}\n`;
+  return section;
+}
+
+function buildSummaryBlock(summary) {
+  return `${SUMMARY_START_MARKER}\n${buildSummarySection(summary).trim()}\n${SUMMARY_END_MARKER}`;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/scripts/hooks/session-start.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * session-start.js — SessionStart hook for SCC.
+ *
+ * Detects Salesforce project context and prints a summary:
+ *   - sfdx-project.json detection
+ *   - SF CLI version
+ *   - Connected scratch orgs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const CWD = process.cwd();
+
+/**
+ * Run a command and return stdout string, or null on failure.
+ */
+function run(cmd, args, options = {}) {
+  const result = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    timeout: 8000,
+    cwd: options.cwd || CWD,
+    env: process.env,
+  });
+  if (result.status !== 0 || result.error) return null;
+  return (result.stdout || '').trim();
+}
+
+/**
+ * Parse sfdx-project.json for project metadata.
+ */
+function readSfdxProject(dir) {
+  const filePath = path.join(dir, 'sfdx-project.json');
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Walk up directories to find sfdx-project.json.
+ */
+function findSfdxRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.join(dir, 'sfdx-project.json'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Get SF CLI version.
+ */
+function getSfCliVersion() {
+  // Try 'sf' first (v2), then 'sfdx' (v1)
+  const sfVersion = run('sf', ['--version']);
+  if (sfVersion) return { cli: 'sf', version: sfVersion };
+
+  const sfdxVersion = run('sfdx', ['--version']);
+  if (sfdxVersion) return { cli: 'sfdx', version: sfdxVersion, deprecated: true };
+
+  return null;
+}
+
+/**
+ * List connected Salesforce orgs.
+ */
+function listOrgs() {
+  // Try sf org list
+  const sfOut = run('sf', ['org', 'list', '--json']);
+  if (sfOut) {
+    try {
+      const data = JSON.parse(sfOut);
+      const orgs = [];
+      const result = data.result || data;
+
+      // Non-scratch orgs (devhubs, sandboxes, etc.)
+      const nonScratch = Array.isArray(result.nonScratchOrgs) ? result.nonScratchOrgs : [];
+      for (const org of nonScratch) {
+        orgs.push({
+          alias: org.alias || org.username,
+          username: org.username,
+          type: org.connectedStatus === 'Connected' ? 'connected' : 'disconnected',
+          isDevHub: org.isDevHub || false,
+          orgType: 'non-scratch',
+        });
+      }
+
+      // Scratch orgs
+      const scratch = Array.isArray(result.scratchOrgs) ? result.scratchOrgs : [];
+      for (const org of scratch) {
+        orgs.push({
+          alias: org.alias || org.username,
+          username: org.username,
+          type: org.connectedStatus === 'Connected' ? 'connected' : 'disconnected',
+          isDefaultOrg: org.isDefaultOrg || false,
+          expirationDate: org.expirationDate || null,
+          orgType: 'scratch',
+        });
+      }
+
+      return orgs;
+    } catch { /* fall through */ }
+  }
+
+  // Fallback: sfdx force:org:list
+  const sfdxOut = run('sfdx', ['force:org:list', '--json']);
+  if (sfdxOut) {
+    try {
+      const data = JSON.parse(sfdxOut);
+      const result = data.result || {};
+      const orgs = [];
+      for (const org of [...(result.nonScratchOrgs || []), ...(result.scratchOrgs || [])]) {
+        orgs.push({
+          alias: org.alias || org.username,
+          username: org.username,
+          type: org.connectedStatus === 'Connected' ? 'connected' : 'disconnected',
+        });
+      }
+      return orgs;
+    } catch { /* ignore */ }
+  }
+
+  return null;
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+const sfdxRoot = findSfdxRoot(CWD);
+const isSalesforceProject = sfdxRoot !== null;
+
+if (!isSalesforceProject) {
+  // Not a Salesforce project — exit silently
+  process.exit(0);
+}
+
+const projectData = readSfdxProject(sfdxRoot);
+const cliInfo = getSfCliVersion();
+
+console.log('\n── Salesforce Dev Context ─────────────────────────────');
+
+if (sfdxRoot !== CWD) {
+  console.log(`Project root : ${sfdxRoot}`);
+} else {
+  console.log(`Project      : ${path.basename(sfdxRoot)}`);
+}
+
+if (projectData) {
+  if (projectData.name) console.log(`Name         : ${projectData.name}`);
+  if (projectData.namespace) console.log(`Namespace    : ${projectData.namespace}`);
+  if (Array.isArray(projectData.packageDirectories)) {
+    const pkgDirs = projectData.packageDirectories.map(d => d.path || d).join(', ');
+    console.log(`Package dirs : ${pkgDirs}`);
+  }
+  if (projectData.sourceApiVersion) console.log(`API version  : ${projectData.sourceApiVersion}`);
+}
+
+if (cliInfo) {
+  if (cliInfo.deprecated) {
+    console.log(`SF CLI       : ${cliInfo.version} [DEPRECATED — upgrade to sf v2]`);
+  } else {
+    console.log(`SF CLI       : ${cliInfo.version}`);
+  }
+} else {
+  console.log(`SF CLI       : not found (install with: npm install -g @salesforce/cli)`);
+}
+
+if (process.env.SF_ORG_ALIAS) {
+  console.log(`Default org  : ${process.env.SF_ORG_ALIAS} (SF_ORG_ALIAS)`);
+}
+
+// List orgs (only if SF CLI is available)
+if (cliInfo) {
+  const orgs = listOrgs();
+  if (orgs && orgs.length > 0) {
+    const connectedOrgs = orgs.filter(o => o.type === 'connected');
+    const scratchOrgs = orgs.filter(o => o.orgType === 'scratch');
+    console.log(`Connected    : ${connectedOrgs.length} org(s)`);
+    if (scratchOrgs.length > 0) {
+      console.log(`Scratch orgs : ${scratchOrgs.length} (${scratchOrgs.filter(o => o.type === 'connected').length} active)`);
+    }
+    // Show default org
+    const defaultOrg = orgs.find(o => o.isDefaultOrg);
+    if (defaultOrg) {
+      const expiry = defaultOrg.expirationDate ? ` (expires: ${defaultOrg.expirationDate})` : '';
+      console.log(`Default org  : ${defaultOrg.alias || defaultOrg.username}${expiry}`);
+    }
+  } else if (orgs !== null) {
+    console.log(`Orgs         : none connected`);
+  }
+}
+
+console.log('───────────────────────────────────────────────────────\n');

package/scripts/hooks/sfdx-scanner-check.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * sfdx-scanner PreBash Hook
+ *
+ * Runs sfdx-scanner (PMD) on modified Apex files before git push or sf deploy.
+ * The AI is still active when this fires, so it can read the violations and
+ * self-heal before proceeding.
+ *
+ * - Lifecycle: PreToolUse (Bash matcher)
+ * - Only fires on: git push, sf project deploy
+ * - Graceful no-op if sfdx-scanner not installed
+ * - Gated behind SCC_HOOK_PROFILE=strict
+ */
+
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+
+function log(msg) {
+  process.stderr.write(`${msg}\n`);
+}
+
+/**
+ * Check if sf scanner is available.
+ */
+function isScannerAvailable() {
+  try {
+    execSync('sf scanner --version', { timeout: 5000, stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get modified Apex files from git diff.
+ */
+function getModifiedApexFiles() {
+  try {
+    const output = execSync('git diff --name-only HEAD', {
+      timeout: 5000,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return output
+      .split('\n')
+      .filter(f => f.endsWith('.cls') || f.endsWith('.trigger'))
+      .filter(f => f.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Run sfdx-scanner on the given files.
+ */
+function runScanner(files) {
+  if (files.length === 0) return [];
+
+  const target = files.join(',');
+  try {
+    const output = execSync(`sf scanner run --target "${target}" --format json --engine pmd`, {
+      timeout: 40000,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    return JSON.parse(output);
+  } catch (err) {
+    // Scanner returns non-zero when violations found, output is still valid JSON
+    if (err.stdout) {
+      try {
+        return JSON.parse(err.stdout);
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+}
+
+function run(rawInput) {
+  try {
+    const input = JSON.parse(rawInput);
+    const command = String(input.tool_input?.command || '');
+
+    // Only intercept git push and sf deploy commands
+    const isGitPush = /\bgit\s+push\b/.test(command);
+    const isDeploy = /\bsf\s+project\s+deploy\s+start\b/.test(command);
+    if (!isGitPush && !isDeploy) return rawInput;
+
+    // Check if scanner is available
+    if (!isScannerAvailable()) return rawInput;
+
+    // Get modified Apex files
+    const files = getModifiedApexFiles();
+    if (files.length === 0) return rawInput;
+
+    // Run scanner
+    const violations = runScanner(files);
+    if (!Array.isArray(violations) || violations.length === 0) return rawInput;
+
+    // Count by severity
+    const critical = violations.filter(v => v.severity <= 1).length;
+    const high = violations.filter(v => v.severity === 2).length;
+    const medium = violations.filter(v => v.severity === 3).length;
+
+    if (critical + high === 0) return rawInput; // Only warn on critical/high
+
+    log(`\n[SCC Scanner] Found ${violations.length} PMD violation(s) in ${files.length} file(s):`);
+    for (const v of violations.filter(v2 => v2.severity <= 2).slice(0, 10)) {
+      const sev = v.severity === 1 ? 'CRITICAL' : 'HIGH';
+      const file = path.basename(v.fileName || '');
+      log(`  [${sev}] ${file}:${v.line} — ${v.message || v.ruleName}`);
+    }
+    if (violations.filter(v2 => v2.severity <= 2).length > 10) {
+      log(`  ... and ${violations.filter(v2 => v2.severity <= 2).length - 10} more`);
+    }
+    log('  Recommend fixing before push. Run /sf-quality-gate for details.\n');
+  } catch {
+    // Ignore errors — never block the user
+  }
+  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 };