scc-universal 1.1.0

package/scripts/cli/install-apply.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * install-apply.js — Apply SCC content installation.
+ *
+ * Usage:
+ *   node install-apply.js [target] [--profile <name>] [--target <name>] [--dry-run] [--help]
+ *
+ * Targets: apex, lwc, all (shorthand for 'full' profile)
+ * Profiles: core, apex, lwc, devops, security, full
+ */
+
+const path = require('path');
+const { executeInstall, VALID_TARGETS, VALID_PROFILES } = require('../lib/install-executor');
+const { loadInstallConfig } = require('../lib/install-config');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+scc install — Install SCC content
+
+Usage:
+  scc install [target] [options]
+  scc install --profile <name> --target <name>
+
+Shorthand targets:
+  apex              Install Apex profile content
+  lwc               Install LWC profile content
+  all               Install full profile content
+
+Options:
+  --profile <name>  Profile to install: core|apex|lwc|devops|security|full (default: full)
+  --target <name>   Install target: ${VALID_TARGETS.join('|')} (default: claude)
+  --config <path>   Load install config from scc-install.json (CLI args override config)
+  --project <dir>   Project root directory (default: current directory)
+  --dry-run         Show what would be installed without making changes
+  --help, -h        Show this help
+
+Examples:
+  scc install apex
+  scc install all
+  scc install --config scc-install.json
+  scc install --config scc-install.json --target cursor
+  scc install --profile security --target claude
+  scc install --profile lwc --target cursor --dry-run
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = {
+    profile: null,
+    target: null,
+    projectRoot: process.cwd(),
+    dryRun: false,
+    help: false,
+    config: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else if (arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if (arg === '--config' && args[i + 1]) {
+      opts.config = args[++i];
+    } else if (arg === '--profile' && args[i + 1]) {
+      opts.profile = args[++i];
+    } else if (arg === '--target' && args[i + 1]) {
+      opts.target = args[++i];
+    } else if (arg === '--project' && args[i + 1]) {
+      opts.projectRoot = path.resolve(args[++i]);
+    } else if (!arg.startsWith('--')) {
+      // Positional: treat as shorthand target/profile
+      switch (arg) {
+        case 'apex':
+          opts.profile = opts.profile || 'apex';
+          break;
+        case 'lwc':
+          opts.profile = opts.profile || 'lwc';
+          break;
+        case 'all':
+          opts.profile = opts.profile || 'full';
+          break;
+        case 'core':
+        case 'devops':
+        case 'security':
+        case 'full':
+          opts.profile = opts.profile || arg;
+          break;
+        default:
+          // Could be a target name
+          if (VALID_TARGETS.includes(arg)) {
+            opts.target = arg;
+          } else {
+            console.error(`[ERROR] Unknown argument: ${arg}`);
+            process.exit(1);
+          }
+      }
+    }
+  }
+
+  return opts;
+}
+
+/**
+ * Merge CLI opts with config file. CLI args override config values.
+ */
+function mergeWithConfig(opts) {
+  if (!opts.config) {
+    // No config file — apply defaults
+    if (!opts.profile) opts.profile = 'full';
+    if (!opts.target) opts.target = 'claude';
+    return opts;
+  }
+
+  try {
+    const config = loadInstallConfig(opts.config);
+    console.log(`[INFO] Loaded config from ${config.path}`);
+
+    // CLI args override config values
+    if (!opts.profile) opts.profile = config.profile || 'full';
+    if (!opts.target) opts.target = config.target || 'claude';
+
+    return opts;
+  } catch (err) {
+    console.error(`[ERROR] Config: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function validateArgs(opts) {
+  if (!VALID_PROFILES.includes(opts.profile)) {
+    console.error(`[ERROR] Invalid profile: ${opts.profile}`);
+    console.error(`Valid profiles: ${VALID_PROFILES.join(', ')}`);
+    process.exit(1);
+  }
+  if (!VALID_TARGETS.includes(opts.target)) {
+    console.error(`[ERROR] Invalid target: ${opts.target}`);
+    console.error(`Valid targets: ${VALID_TARGETS.join(', ')}`);
+    process.exit(1);
+  }
+}
+
+const opts = mergeWithConfig(parseArgs(process.argv));
+
+if (opts.help) {
+  showHelp(0);
+}
+
+validateArgs(opts);
+
+try {
+  const result = executeInstall(opts.profile, opts.target, {
+    dryRun: opts.dryRun,
+    projectRoot: opts.projectRoot,
+  });
+
+  if (result.fileCount === 0 && !opts.dryRun) {
+    console.log('\n[INFO] No files were installed. Check your manifests or profile definition.');
+  } else {
+    console.log('\nDone.');
+  }
+} catch (err) {
+  console.error(`\n[ERROR] Installation failed: ${err.message}`);
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+}

package/scripts/cli/uninstall.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * uninstall.js — Remove SCC-managed files.
+ *
+ * Reads the state store to find all files installed by SCC and removes them.
+ * Optionally prunes empty directories.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { loadState, clearState, removeFiles } = require('../lib/state-store');
+const { fileExists } = require('../lib/utils');
+
+function showHelp(exitCode = 0) {
+  console.log(`
+scc uninstall — Remove SCC-managed files
+
+Usage:
+  scc uninstall [options]
+
+Options:
+  --target <name>  Only uninstall files for a specific target
+  --dry-run        Show what would be removed without making changes
+  --yes, -y        Skip confirmation prompt
+  --keep-state     Remove files but keep the state store
+  --json           Output result as JSON
+  --help, -h       Show this help
+
+Notes:
+  Only files tracked in the SCC state store will be removed.
+  Files you manually added to .claude/ etc. will not be touched.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = { target: null, dryRun: false, yes: false, keepState: false, json: false, help: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--dry-run') opts.dryRun = true;
+    else if (arg === '--yes' || arg === '-y') opts.yes = true;
+    else if (arg === '--keep-state') opts.keepState = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--target' && args[i + 1]) opts.target = args[++i];
+  }
+  return opts;
+}
+
+async function confirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+async function main() {
+  const opts = parseArgs(process.argv);
+  if (opts.help) showHelp(0);
+
+  const state = loadState();
+
+  if (!state.installedFiles || state.installedFiles.length === 0) {
+    const msg = 'No SCC installation found. Nothing to uninstall.';
+    if (opts.json) console.log(JSON.stringify({ status: 'not-installed', message: msg }));
+    else console.log(`[INFO] ${msg}`);
+    process.exit(0);
+  }
+
+  // Filter by target if specified
+  let filesToRemove = state.installedFiles;
+  if (opts.target) {
+    filesToRemove = filesToRemove.filter(f => f.target === opts.target);
+    if (filesToRemove.length === 0) {
+      console.log(`[INFO] No files found for target: ${opts.target}`);
+      process.exit(0);
+    }
+  }
+
+  // Only consider files that actually exist
+  const existingFiles = filesToRemove.filter(f => fileExists(f.destPath));
+  const missingFiles = filesToRemove.filter(f => !fileExists(f.destPath));
+
+  if (!opts.json) {
+    console.log(`\nSCC Uninstall${opts.dryRun ? ' (DRY RUN)' : ''}`);
+    console.log(`${'─'.repeat(50)}`);
+    console.log(`Files to remove : ${existingFiles.length}`);
+    if (missingFiles.length > 0) {
+      console.log(`Already missing : ${missingFiles.length} (will clear from state)`);
+    }
+    console.log();
+
+    if (opts.dryRun || opts.json) {
+      // just list
+    } else if (existingFiles.length > 0) {
+      console.log('Files that will be deleted:');
+      for (const f of existingFiles) {
+        console.log(`  ${f.destPath}`);
+      }
+      console.log();
+    }
+  }
+
+  if (opts.dryRun) {
+    if (opts.json) {
+      console.log(JSON.stringify({ status: 'dry-run', wouldRemove: existingFiles.map(f => f.destPath), alreadyMissing: missingFiles.map(f => f.destPath) }, null, 2));
+    } else {
+      console.log(`[dry-run] Would remove ${existingFiles.length} file(s).`);
+    }
+    process.exit(0);
+  }
+
+  // Prompt for confirmation unless --yes
+  if (!opts.yes && !opts.json && existingFiles.length > 0) {
+    const answer = await confirm(`Remove ${existingFiles.length} file(s)? [y/N] `);
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('Aborted.');
+      process.exit(0);
+    }
+  }
+
+  // Remove files
+  const removed = [];
+  const errors = [];
+
+  for (const f of existingFiles) {
+    try {
+      fs.unlinkSync(f.destPath);
+      removed.push(f.destPath);
+      if (!opts.json) console.log(`  [REMOVED] ${f.destPath}`);
+    } catch (err) {
+      errors.push({ path: f.destPath, error: err.message });
+      if (!opts.json) console.error(`  [ERROR] Failed to remove ${f.destPath}: ${err.message}`);
+    }
+  }
+
+  // Try to prune empty directories
+  const dirsToCheck = new Set(existingFiles.map(f => path.dirname(f.destPath)));
+  const pruned = [];
+  for (const dir of dirsToCheck) {
+    try {
+      const entries = fs.readdirSync(dir);
+      if (entries.length === 0) {
+        fs.rmdirSync(dir);
+        pruned.push(dir);
+        if (!opts.json) console.log(`  [PRUNED] empty dir: ${dir}`);
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Update state
+  if (!opts.keepState) {
+    if (opts.target) {
+      // Only remove files for this target from state
+      removeFiles(filesToRemove.map(f => f.destPath));
+    } else {
+      clearState();
+    }
+  }
+
+  const result = {
+    status: errors.length > 0 ? 'partial' : 'ok',
+    removed: removed.length,
+    failed: errors.length,
+    prunedDirs: pruned.length,
+    removedFiles: removed,
+    failedFiles: errors,
+  };
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log();
+    console.log(`Removed: ${removed.length} file(s).`);
+    if (pruned.length > 0) console.log(`Pruned : ${pruned.length} empty director(ies).`);
+    if (errors.length > 0) console.log(`Errors : ${errors.length} file(s) could not be removed.`);
+    if (!opts.keepState) console.log('State  : cleared.');
+  }
+
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error(`[FATAL] ${err.message}`);
+  process.exit(1);
+});

package/scripts/hooks/check-console-log.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+/**
+ * Stop Hook: Check for console.log statements in modified LWC/JS files
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs after each response and checks if any modified JavaScript/TypeScript
+ * files contain console.log statements. Particularly useful for LWC development
+ * where console.log should be removed before deployment.
+ *
+ * Exclusions: test files, config files, and scripts/ directory.
+ */
+
+const fs = require('fs');
+
+// Files where console.log is expected and should not trigger warnings
+const EXCLUDED_PATTERNS = [
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/,
+  /\.config\.[jt]s$/,
+  /scripts\//,
+  /__tests__\//,
+  /__mocks__\//,
+];
+
+function isGitRepo() {
+  try {
+    const { execSync } = require('child_process');
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getGitModifiedFiles(patterns) {
+  try {
+    const { execSync } = require('child_process');
+    const output = execSync('git diff --name-only HEAD 2>/dev/null || git diff --name-only', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    if (!output) return [];
+    const files = output.split('\n').filter(Boolean);
+    if (patterns && patterns.length > 0) {
+      return files.filter(f => patterns.some(p => new RegExp(p).test(f)));
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+
+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 {
+    if (!isGitRepo()) {
+      process.stdout.write(data);
+      process.exit(0);
+    }
+
+    const files = getGitModifiedFiles(['\\.tsx?$', '\\.jsx?$'])
+      .filter(f => fs.existsSync(f))
+      .filter(f => !EXCLUDED_PATTERNS.some(pattern => pattern.test(f)));
+
+    let hasConsole = false;
+
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file, 'utf8');
+        if (content && content.includes('console.log')) {
+          console.error(`[Hook] WARNING: console.log found in ${file}`);
+          hasConsole = true;
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+
+    if (hasConsole) {
+      console.error('[Hook] Remove console.log statements before committing (especially in LWC)');
+    }
+  } catch (err) {
+    console.error(`[Hook] check-console-log error: ${err.message}`);
+  }
+
+  // Always output the original data
+  process.stdout.write(data);
+  process.exit(0);
+});

package/scripts/hooks/check-hook-enabled.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Helper: Check if a hook is enabled based on profile and disabled list.
+ * Returns "yes" or "no" based on SCC_HOOK_PROFILE and SCC_DISABLED_HOOKS.
+ */
+
+const { isHookEnabled } = require('../lib/hook-flags');
+
+const [, , hookId, profilesCsv] = process.argv;
+if (!hookId) {
+  process.stdout.write('yes');
+  process.exit(0);
+}
+
+process.stdout.write(isHookEnabled(hookId, { profiles: profilesCsv }) ? 'yes' : 'no');

package/scripts/hooks/check-platform-docs-age.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * SessionStart hook: checks if platform reference docs are outdated.
+ * Warns the user to run /update-platform-docs if files haven't been
+ * verified in more than SCC_PLATFORM_DOCS_AGE_MONTHS months (default: 4).
+ *
+ * Uses CLAUDE_PLUGIN_ROOT / SCC_PLUGIN_ROOT env vars — no hardcoded paths.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT
+  || process.env.SCC_PLUGIN_ROOT
+  || path.resolve(__dirname, '../..');
+
+const MONTHS_THRESHOLD = parseInt(
+  process.env.SCC_PLATFORM_DOCS_AGE_MONTHS || '4',
+  10
+);
+
+const FILES_TO_CHECK = [
+  path.join(PLUGIN_ROOT, 'skills', '_reference', 'DEPRECATIONS.md'),
+  path.join(PLUGIN_ROOT, 'skills', '_reference', 'API_VERSIONS.md')
+];
+
+for (const filePath of FILES_TO_CHECK) {
+  if (!fs.existsSync(filePath)) continue;
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/Last verified:\s*(\d{4}-\d{2}-\d{2})/);
+  if (!match) continue;
+
+  const verifiedDate = new Date(match[1]);
+  const threshold = new Date();
+  threshold.setMonth(threshold.getMonth() - MONTHS_THRESHOLD);
+
+  if (verifiedDate < threshold) {
+    const name = path.basename(filePath);
+    const age = Math.round((Date.now() - verifiedDate.getTime()) / (1000 * 60 * 60 * 24 * 30));
+    console.log(
+      `Platform docs outdated: ${name} was last verified ${match[1]} (${age} months ago). ` +
+      `Run /update-platform-docs to refresh with latest Salesforce release info.`
+    );
+  }
+}

package/scripts/hooks/cost-tracker.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Cost Tracker Hook
+ *
+ * Appends lightweight session usage metrics to ~/.claude/metrics/costs.jsonl.
+ * Runs on Stop event to log token usage and estimated costs.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ensureDir } = require('../lib/utils');
+
+const MAX_STDIN = 1024 * 1024;
+
+function getClaudeDir() {
+  return path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.claude');
+}
+
+function toNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function estimateCost(model, inputTokens, outputTokens) {
+  const table = {
+    'haiku': { in: 0.8, out: 4.0 },
+    'sonnet': { in: 3.0, out: 15.0 },
+    'opus': { in: 15.0, out: 75.0 },
+  };
+
+  const normalized = String(model || '').toLowerCase();
+  let rates = table.sonnet;
+  if (normalized.includes('haiku')) rates = table.haiku;
+  if (normalized.includes('opus')) rates = table.opus;
+
+  const cost = (inputTokens / 1_000_000) * rates.in + (outputTokens / 1_000_000) * rates.out;
+  return Math.round(cost * 1e6) / 1e6;
+}
+
+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', () => {
+  try {
+    const input = raw.trim() ? JSON.parse(raw) : {};
+    const usage = input.usage || input.token_usage || {};
+    const inputTokens = toNumber(usage.input_tokens || usage.prompt_tokens || 0);
+    const outputTokens = toNumber(usage.output_tokens || usage.completion_tokens || 0);
+
+    const model = String(input.model || process.env.CLAUDE_MODEL || 'unknown');
+    const sessionId = String(process.env.CLAUDE_SESSION_ID || 'default');
+
+    const metricsDir = path.join(getClaudeDir(), 'metrics');
+    ensureDir(metricsDir);
+
+    const row = {
+      timestamp: new Date().toISOString(),
+      session_id: sessionId,
+      model,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      estimated_cost_usd: estimateCost(model, inputTokens, outputTokens),
+    };
+
+    fs.appendFileSync(path.join(metricsDir, 'costs.jsonl'), `${JSON.stringify(row)}\n`);
+  } catch {
+    // Keep hook non-blocking
+  }
+
+  process.stdout.write(raw);
+});

package/scripts/hooks/doc-file-warning.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Doc file warning hook (PreToolUse - Write)
+ * Warns about non-standard documentation files.
+ * Exit code 0 always (warns only, never blocks).
+ */
+
+'use strict';
+
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+let data = '';
+
+function isAllowedDocPath(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const basename = path.basename(filePath);
+
+  if (!/\.(md|txt)$/i.test(filePath)) return true;
+
+  if (/^(README|CLAUDE|AGENTS|CONTRIBUTING|CHANGELOG|LICENSE|SKILL|MEMORY|WORKLOG)\.md$/i.test(basename)) {
+    return true;
+  }
+
+  if (/\.claude\/(commands|plans|projects)\//.test(normalized)) {
+    return true;
+  }
+
+  if (/(^|\/)(docs|skills|\.history|memory)\//.test(normalized)) {
+    return true;
+  }
+
+  if (/\.plan\.md$/i.test(basename)) {
+    return true;
+  }
+
+  return false;
+}
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += c.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(data);
+    const filePath = String((input.tool_input && input.tool_input.file_path) || '');
+
+    if (filePath && !isAllowedDocPath(filePath)) {
+      console.error('[Hook] WARNING: Non-standard documentation file detected');
+      console.error(`[Hook] File: ${filePath}`);
+      console.error('[Hook] Consider consolidating into README.md or docs/ directory');
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  process.stdout.write(data);
+});