@nebulit/embuilder 0.1.39

package/templates/.claude/hooks/analyzers/code-quality-checker.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+/**
+ * Example Analyzer: Code Quality Checker
+ *
+ * This analyzer checks for common code quality issues in the diff:
+ * - Debug statements (console.log, debugger)
+ * - TODO/FIXME comments
+ * - Large file changes
+ * - Potential sensitive data (API keys, passwords)
+ */
+
+import { readFileSync } from 'fs';
+
+interface HookData {
+  event: string;
+  timestamp: string;
+  repository: string;
+  branch: string;
+  staged_diff: string;
+  unstaged_diff: string;
+  changed_files: string[];
+  stats: {
+    staged_files: number;
+    has_staged_changes: boolean;
+    has_unstaged_changes: boolean;
+  };
+}
+
+interface Issue {
+  severity: 'warning' | 'info';
+  message: string;
+}
+
+async function analyzeDiff(diff: string): Promise<Issue[]> {
+  const issues: Issue[] = [];
+  const lines = diff.split('\n');
+
+  // Only check added lines (starting with +)
+  const addedLines = lines.filter(line => line.startsWith('+') && !line.startsWith('+++'));
+
+  // Check for console.log statements
+  const consoleLogs = addedLines.filter(line => /console\.(log|debug|info|warn|error)/.test(line));
+  if (consoleLogs.length > 0) {
+    issues.push({
+      severity: 'warning',
+      message: `Found ${consoleLogs.length} console.log statement(s) - consider removing debug code`
+    });
+  }
+
+  // Check for debugger statements
+  const debuggers = addedLines.filter(line => /\bdebugger\b/.test(line));
+  if (debuggers.length > 0) {
+    issues.push({
+      severity: 'warning',
+      message: `Found ${debuggers.length} debugger statement(s) - remove before committing`
+    });
+  }
+
+  // Check for TODO/FIXME comments
+  const todos = addedLines.filter(line => /(TODO|FIXME|XXX|HACK)/i.test(line));
+  if (todos.length > 0) {
+    issues.push({
+      severity: 'info',
+      message: `Found ${todos.length} TODO/FIXME comment(s) - ensure they're tracked`
+    });
+  }
+
+  // Check for potential API keys or secrets
+  const potentialSecrets = addedLines.filter(line =>
+    /(api[_-]?key|secret|password|token|auth[_-]?key)[\s]*[:=][\s]*['"][^'"]{20,}['"]/.test(line.toLowerCase())
+  );
+  if (potentialSecrets.length > 0) {
+    issues.push({
+      severity: 'warning',
+      message: `⚠️  SECURITY: Found ${potentialSecrets.length} potential secret(s) - verify no credentials are committed`
+    });
+  }
+
+  return issues;
+}
+
+interface AnalyzerResult {
+  approved: boolean;
+  reason?: string;
+}
+
+async function main() {
+  try {
+    // Read JSON data from stdin
+    const input = readFileSync(0, 'utf-8');
+    const data: HookData = JSON.parse(input);
+
+    console.log('🔍 Code Quality Analysis:');
+
+    // Analyze staged changes
+    const stagedIssues = await analyzeDiff(data.staged_diff);
+    const unstagedIssues = await analyzeDiff(data.unstaged_diff);
+
+    const allIssues = [...stagedIssues, ...unstagedIssues];
+
+    if (allIssues.length === 0) {
+      console.log('   ✅ No issues found');
+
+      const result: AnalyzerResult = {
+        approved: true,
+        reason: 'No code quality issues found'
+      };
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    // Group by severity
+    const warnings = allIssues.filter(i => i.severity === 'warning');
+    const infos = allIssues.filter(i => i.severity === 'info');
+
+    if (warnings.length > 0) {
+      console.log('\n   ⚠️  Warnings:');
+      warnings.forEach(issue => console.log(`      - ${issue.message}`));
+    }
+
+    if (infos.length > 0) {
+      console.log('\n   ℹ️  Info:');
+      infos.forEach(issue => console.log(`      - ${issue.message}`));
+    }
+
+    // Check for blocking issues (potential secrets)
+    const hasSecrets = warnings.some(w => w.message.includes('SECURITY'));
+
+    let result: AnalyzerResult;
+    if (hasSecrets) {
+      // BLOCK commit if potential secrets found
+      result = {
+        approved: false,
+        reason: 'Potential secrets detected - verify no credentials are committed'
+      };
+    } else {
+      // Just warn but allow commit
+      result = {
+        approved: true,
+        reason: `Code quality warnings found (${warnings.length} warnings, ${infos.length} info)`
+      };
+    }
+
+    console.log('\n' + JSON.stringify(result));
+
+  } catch (error) {
+    console.error('❌ Error in code quality checker:', error);
+    console.log(JSON.stringify({ approved: true, reason: 'analyzer_error' }));
+    process.exit(1);
+  }
+}
+
+main();

package/templates/.claude/hooks/analyzers/code-quality.md

@@ -0,0 +1,54 @@
+# Code Quality Analyzer
+
+## Configuration
+
+```yaml
+name: code-quality-checker
+blocking: secrets-only
+priority: 1
+```
+
+## Prompt
+
+You are a code quality analyzer reviewing git commit changes before they are committed.
+
+Analyze the provided diff and check for:
+
+1. **Debug Code** - console.log, debugger statements, commented-out code
+2. **Security Issues** - Potential secrets, API keys, passwords, tokens hardcoded in code
+3. **Code Smells** - TODO/FIXME comments, magic numbers, overly complex code
+4. **Best Practices** - Proper error handling, appropriate variable names
+
+## Review Criteria
+
+**BLOCK the commit (approved: false) if:**
+- Potential secrets/credentials detected (API keys, passwords, tokens with values)
+- Obvious security vulnerabilities (eval, dangerouslySetInnerHTML without sanitization)
+
+**WARN but ALLOW (approved: true) if:**
+- console.log or debugger statements found
+- TODO/FIXME comments present
+- Minor code quality issues
+
+## Response Format
+
+Return your analysis as JSON:
+
+```json
+{
+  "approved": boolean,
+  "reason": "Brief explanation",
+  "details": [
+    "Specific issue 1",
+    "Specific issue 2"
+  ]
+}
+```
+
+## Input Data
+
+You will receive:
+- `staged_diff`: The git diff of staged changes
+- `changed_files`: List of files being committed
+- `branch`: Current git branch
+- Full git context

package/templates/.claude/hooks/analyzers/commit-blocker-example.ts.disabled

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * Example Analyzer: Commit Blocker
+ *
+ * This analyzer demonstrates how to BLOCK commits based on specific conditions.
+ * It's disabled by default (note the .disabled extension).
+ *
+ * To enable: Rename to commit-blocker-example.ts
+ */
+
+import { readFileSync } from 'fs';
+
+interface HookData {
+  event: string;
+  timestamp: string;
+  repository: string;
+  branch: string;
+  staged_diff: string;
+  unstaged_diff: string;
+  changed_files: string[];
+  stats: {
+    staged_files: number;
+    has_staged_changes: boolean;
+    has_unstaged_changes: boolean;
+  };
+}
+
+interface AnalyzerResult {
+  approved: boolean;
+  reason?: string;
+}
+
+async function main() {
+  try {
+    // Read JSON data from stdin
+    const input = readFileSync(0, 'utf-8');
+    const data: HookData = JSON.parse(input);
+
+    console.log('🚫 Commit Blocker Example:');
+
+    // Example 1: Block commits to main branch
+    if (data.branch === 'main') {
+      const result: AnalyzerResult = {
+        approved: false,
+        reason: 'Direct commits to main branch are not allowed'
+      };
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    // Example 2: Block commits with too many files
+    const MAX_FILES = 50;
+    if (data.changed_files.length > MAX_FILES) {
+      const result: AnalyzerResult = {
+        approved: false,
+        reason: `Too many files changed (${data.changed_files.length} > ${MAX_FILES}) - split into smaller commits`
+      };
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    // Example 3: Block if critical files changed without tests
+    const criticalFiles = data.changed_files.filter(f =>
+      f.includes('/api/') ||
+      f.includes('/core/') ||
+      f.endsWith('Handler.ts')
+    );
+
+    const testFiles = data.changed_files.filter(f => f.endsWith('.test.ts'));
+
+    if (criticalFiles.length > 0 && testFiles.length === 0) {
+      const result: AnalyzerResult = {
+        approved: false,
+        reason: 'Critical files changed but no test files updated - add tests first'
+      };
+      console.log(`\n   Critical files: ${criticalFiles.join(', ')}`);
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    // Example 4: Block if package.json changed without package-lock.json
+    const packageJsonChanged = data.changed_files.includes('package.json');
+    const lockfileChanged = data.changed_files.includes('package-lock.json');
+
+    if (packageJsonChanged && !lockfileChanged) {
+      const result: AnalyzerResult = {
+        approved: false,
+        reason: 'package.json changed but package-lock.json not updated - run npm install'
+      };
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    // All checks passed
+    console.log('   ✅ All blocking checks passed');
+    const result: AnalyzerResult = {
+      approved: true,
+      reason: 'No blocking issues found'
+    };
+    console.log('\n' + JSON.stringify(result));
+
+  } catch (error) {
+    console.error('❌ Error in commit blocker:', error);
+    console.log(JSON.stringify({ approved: true, reason: 'analyzer_error' }));
+    process.exit(1);
+  }
+}
+
+main();

package/templates/.claude/hooks/analyzers/commit-policy.md

@@ -0,0 +1,49 @@
+# Commit Policy Enforcer
+
+## Configuration
+
+```yaml
+name: commit-policy
+blocking: true
+priority: 0
+```
+
+## Prompt
+
+You are a commit policy enforcer ensuring repository standards are maintained.
+
+Review the commit and enforce these policies:
+
+1. **Branch Protection** - Check if direct commits to protected branches (main, production) are allowed
+2. **Commit Size** - Ensure commits aren't too large (>50 files suggests should be split)
+3. **Critical File Protection** - If critical files change (package.json, config files), ensure related files also change
+4. **Required Files** - If package.json changes, package-lock.json should also change
+
+## Review Criteria
+
+**BLOCK the commit (approved: false) if:**
+- Direct commit to 'main' or 'production' branch
+- More than 50 files changed in a single commit
+- package.json changed but package-lock.json didn't change
+- Critical API files changed without corresponding test updates
+
+**ALLOW (approved: true) otherwise**
+
+## Response Format
+
+```json
+{
+  "approved": boolean,
+  "reason": "Policy check result",
+  "details": [
+    "Policy violation or approval reason"
+  ]
+}
+```
+
+## Input Data
+
+You will receive:
+- `branch`: Current branch name
+- `changed_files`: List and count of files
+- `staged_diff`: Full diff of changes

package/templates/.claude/hooks/analyzers/event-model-validator.md

@@ -0,0 +1,49 @@
+# Event Model Validator
+
+## Configuration
+
+```yaml
+name: event-model-validator
+blocking: false
+priority: 2
+```
+
+## Prompt
+
+You are an event model architecture validator for event-sourced systems.
+
+Review the git diff and validate that changes follow event modeling best practices:
+
+1. **Event Naming** - Events should be in past tense (e.g., "UserRegistered", "OrderPlaced")
+2. **Command Naming** - Commands should be imperative (e.g., "RegisterUser", "PlaceOrder")
+3. **Test Coverage** - When logic files change (CommandHandler, Projection, processor), corresponding test files should also change
+4. **Slice Structure** - Files should follow the standard slice organization pattern
+
+## Review Criteria
+
+**Always ALLOW (approved: true)** - This analyzer provides guidance but doesn't block commits.
+
+Provide warnings for:
+- Event names that don't follow past-tense convention
+- Missing test updates when logic changes
+- Deviations from slice structure patterns
+
+## Response Format
+
+```json
+{
+  "approved": true,
+  "reason": "Event model validation completed",
+  "details": [
+    "⚠️  Event 'UserRegister' should be 'UserRegistered'",
+    "💡 Logic changed in RegisterUser slice but no test updates"
+  ]
+}
+```
+
+## Input Data
+
+You will receive:
+- `staged_diff`: Changes being committed
+- `changed_files`: List of modified files (check for *Command.ts, *Projection.ts, *.test.ts)
+- Full repository context

package/templates/.claude/hooks/analyzers/event-model-validator.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * Example Analyzer: Event Model Validator
+ *
+ * This analyzer validates changes to event model slices:
+ * - Checks if event names follow past-tense convention
+ * - Validates command naming (imperative form)
+ * - Ensures test files are updated when logic changes
+ * - Verifies TypeScript files follow slice structure
+ */
+
+import { readFileSync } from 'fs';
+
+interface HookData {
+  event: string;
+  timestamp: string;
+  repository: string;
+  branch: string;
+  staged_diff: string;
+  unstaged_diff: string;
+  changed_files: string[];
+  stats: {
+    staged_files: number;
+    has_staged_changes: boolean;
+    has_unstaged_changes: boolean;
+  };
+}
+
+interface ValidationResult {
+  valid: boolean;
+  warnings: string[];
+  suggestions: string[];
+}
+
+function validateEventNames(diff: string): ValidationResult {
+  const warnings: string[] = [];
+  const suggestions: string[] = [];
+
+  // Look for event definitions in the diff
+  const eventPattern = /interface\s+(\w+Event)\s*{/g;
+  const lines = diff.split('\n').filter(line => line.startsWith('+'));
+  const content = lines.join('\n');
+
+  const matches = [...content.matchAll(eventPattern)];
+
+  for (const match of matches) {
+    const eventName = match[1];
+
+    // Check if event name ends with past tense indicators
+    const pastTenseEndings = ['ed', 'Created', 'Updated', 'Deleted', 'Activated', 'Deactivated', 'Registered', 'Confirmed'];
+    const hasPastTense = pastTenseEndings.some(ending => eventName.includes(ending));
+
+    if (!hasPastTense) {
+      warnings.push(`Event name "${eventName}" may not follow past-tense convention`);
+      suggestions.push(`Consider renaming to express a completed action (e.g., "${eventName}Created" or "${eventName}Updated")`);
+    }
+  }
+
+  return {
+    valid: warnings.length === 0,
+    warnings,
+    suggestions
+  };
+}
+
+function checkSliceStructure(changedFiles: string[]): ValidationResult {
+  const warnings: string[] = [];
+  const suggestions: string[] = [];
+
+  // Group files by slice
+  const sliceFiles = changedFiles.filter(f => f.includes('src/slices/'));
+
+  const sliceMap = new Map<string, string[]>();
+
+  for (const file of sliceFiles) {
+    const match = file.match(/src\/slices\/([^/]+)\//);
+    if (match) {
+      const sliceName = match[1];
+      if (!sliceMap.has(sliceName)) {
+        sliceMap.set(sliceName, []);
+      }
+      sliceMap.get(sliceName)!.push(file);
+    }
+  }
+
+  // Check if test files are included when logic changes
+  for (const [sliceName, files] of sliceMap.entries()) {
+    const hasLogicChange = files.some(f =>
+      f.endsWith('Command.ts') ||
+      f.endsWith('CommandHandler.ts') ||
+      f.endsWith('Projection.ts') ||
+      f.endsWith('processor.ts')
+    );
+
+    const hasTestChange = files.some(f => f.endsWith('.test.ts'));
+
+    if (hasLogicChange && !hasTestChange) {
+      warnings.push(`Logic changed in "${sliceName}" slice but no test file updated`);
+      suggestions.push(`Consider updating ${sliceName}.test.ts to cover the changes`);
+    }
+  }
+
+  return {
+    valid: warnings.length === 0,
+    warnings,
+    suggestions
+  };
+}
+
+interface AnalyzerResult {
+  approved: boolean;
+  reason?: string;
+}
+
+async function main() {
+  try {
+    // Read JSON data from stdin
+    const input = readFileSync(0, 'utf-8');
+    const data: HookData = JSON.parse(input);
+
+    console.log('🏗️  Event Model Validation:');
+
+    // Validate event names
+    const eventValidation = validateEventNames(data.staged_diff);
+
+    // Check slice structure
+    const structureValidation = checkSliceStructure(data.changed_files);
+
+    const allWarnings = [...eventValidation.warnings, ...structureValidation.warnings];
+    const allSuggestions = [...eventValidation.suggestions, ...structureValidation.suggestions];
+
+    if (allWarnings.length === 0) {
+      console.log('   ✅ Event model structure looks good');
+
+      const result: AnalyzerResult = {
+        approved: true,
+        reason: 'Event model validation passed'
+      };
+      console.log('\n' + JSON.stringify(result));
+      return;
+    }
+
+    if (allWarnings.length > 0) {
+      console.log('\n   ⚠️  Validation warnings:');
+      allWarnings.forEach(warning => console.log(`      - ${warning}`));
+    }
+
+    if (allSuggestions.length > 0) {
+      console.log('\n   💡 Suggestions:');
+      allSuggestions.forEach(suggestion => console.log(`      - ${suggestion}`));
+    }
+
+    // Approve but provide warnings
+    const result: AnalyzerResult = {
+      approved: true,
+      reason: `Event model validation warnings (${allWarnings.length} warnings)`
+    };
+
+    console.log('\n' + JSON.stringify(result));
+
+  } catch (error) {
+    console.error('❌ Error in event model validator:', error);
+    console.log(JSON.stringify({ approved: true, reason: 'analyzer_error' }));
+    process.exit(1);
+  }
+}
+
+main();

package/templates/.claude/hooks/analyzers/example-logger.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * Example Analyzer: Simple Logger
+ *
+ * This analyzer receives git diff information and logs basic statistics.
+ * It demonstrates how to parse the JSON payload and extract useful information.
+ * Always approves commits.
+ */
+
+import { readFileSync } from 'fs';
+
+interface HookData {
+  event: string;
+  timestamp: string;
+  repository: string;
+  branch: string;
+  staged_diff: string;
+  unstaged_diff: string;
+  changed_files: string[];
+  stats: {
+    staged_files: number;
+    has_staged_changes: boolean;
+    has_unstaged_changes: boolean;
+  };
+}
+
+interface AnalyzerResult {
+  approved: boolean;
+  reason?: string;
+}
+
+async function main() {
+  try {
+    // Read JSON data from stdin
+    const input = readFileSync(0, 'utf-8');
+    const data: HookData = JSON.parse(input);
+
+    console.log('📊 Commit Analysis:');
+    console.log(`   Branch: ${data.branch}`);
+    console.log(`   Files changed: ${data.changed_files.length}`);
+    console.log(`   Has staged changes: ${data.stats.has_staged_changes}`);
+    console.log(`   Has unstaged changes: ${data.stats.has_unstaged_changes}`);
+
+    // Log changed files
+    if (data.changed_files.length > 0) {
+      console.log('\n📁 Changed files:');
+      data.changed_files.forEach(file => {
+        if (file.trim()) {
+          console.log(`   - ${file}`);
+        }
+      });
+    }
+
+    // Always approve - this is just an informational analyzer
+    const result: AnalyzerResult = {
+      approved: true,
+      reason: 'Logger - informational only'
+    };
+
+    console.log('\n' + JSON.stringify(result));
+
+  } catch (error) {
+    console.error('❌ Error in analyzer:', error);
+    console.log(JSON.stringify({ approved: true, reason: 'analyzer_error' }));
+    process.exit(1);
+  }
+}
+
+main();