claude-cli-advanced-starter-pack 1.0.16 → 1.8.0

package/templates/hooks/happy-mode-detector.template.js

@@ -0,0 +1,214 @@
+/**
+ * Happy Mode Detector Hook
+ *
+ * Auto-detects Happy daemon environment and enables mobile-optimized mode.
+ * Sets appropriate verbosity and response formatting for mobile clients.
+ * Supports multiple detection methods: env var, daemon state, manual config.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  enabled: false,                     // Manual override
+  auto_detect: true,                  // Attempt auto-detection
+  verbosity: 'condensed',             // 'verbose', 'condensed', 'compact'
+  show_file_stats: true,              // Show file operation statistics
+  max_grep_results: 5,                // Limit grep results for mobile
+  checkpoint_interval_minutes: 10,    // Auto-checkpoint frequency
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const HAPPY_MODE_PATH = path.join(process.cwd(), '.claude', 'config', 'happy-mode.json');
+const HAPPY_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.happy', 'daemon.state.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.happy-detected');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.happy_mode || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Check if we've already detected Happy mode this session
+ */
+function hasDetectedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const data = JSON.parse(content);
+      // Session valid for 4 hours
+      if (Date.now() - data.timestamp < 4 * 60 * 60 * 1000) {
+        return data;
+      }
+    }
+  } catch (e) {
+    // Continue with detection
+  }
+  return null;
+}
+
+/**
+ * Mark session as detected
+ */
+function markSessionDetected(result) {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, JSON.stringify({
+      timestamp: Date.now(),
+      ...result,
+    }, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Detect Happy mode via environment variable
+ */
+function detectViaEnvVar() {
+  return process.env.HAPPY_SESSION === 'true';
+}
+
+/**
+ * Detect Happy mode via daemon state file
+ */
+function detectViaDaemonState() {
+  try {
+    if (fs.existsSync(HAPPY_STATE_PATH)) {
+      const state = JSON.parse(fs.readFileSync(HAPPY_STATE_PATH, 'utf8'));
+      // Check if daemon is running and has active session
+      if (state.running && state.current_session) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Daemon not running or state invalid
+  }
+  return false;
+}
+
+/**
+ * Detect Happy mode via manual configuration
+ */
+function detectViaManualConfig() {
+  try {
+    if (fs.existsSync(HAPPY_MODE_PATH)) {
+      const config = JSON.parse(fs.readFileSync(HAPPY_MODE_PATH, 'utf8'));
+      return config.enabled === true;
+    }
+  } catch (e) {
+    // No manual config
+  }
+  return false;
+}
+
+/**
+ * Get detection method description
+ */
+function getDetectionMethod(envVar, daemon, manual) {
+  if (manual) return 'manual_config';
+  if (envVar) return 'env_var';
+  if (daemon) return 'daemon_state';
+  return 'none';
+}
+
+/**
+ * Save Happy mode state for other hooks to use
+ */
+function saveHappyModeState(result) {
+  try {
+    const dir = path.dirname(HAPPY_MODE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(HAPPY_MODE_PATH, JSON.stringify(result, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function happyModeDetector(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Check if already detected this session
+    const cached = hasDetectedThisSession();
+    if (cached) {
+      return approve();
+    }
+
+    const config = loadConfig();
+
+    // Skip detection if auto-detect is disabled
+    if (!config.auto_detect) {
+      const result = {
+        happy_mode: config.enabled,
+        detection_method: config.enabled ? 'manual_override' : 'disabled',
+        config: config,
+      };
+      markSessionDetected(result);
+      return approve();
+    }
+
+    // Try all detection methods
+    const viaEnvVar = detectViaEnvVar();
+    const viaDaemon = detectViaDaemonState();
+    const viaManual = detectViaManualConfig();
+
+    const isHappyMode = viaEnvVar || viaDaemon || viaManual;
+    const detectionMethod = getDetectionMethod(viaEnvVar, viaDaemon, viaManual);
+
+    // Build result object
+    const result = {
+      happy_mode: isHappyMode,
+      detection_method: detectionMethod,
+      detected_at: new Date().toISOString(),
+      config: {
+        verbosity: config.verbosity,
+        show_file_stats: config.show_file_stats,
+        max_grep_results: config.max_grep_results,
+        checkpoint_interval_minutes: config.checkpoint_interval_minutes,
+      },
+    };
+
+    // Save state for other hooks
+    saveHappyModeState(result);
+    markSessionDetected(result);
+
+    // Log detection result
+    if (isHappyMode) {
+      console.log(`[happy-mode-detector] Happy mode ENABLED (via ${detectionMethod})`);
+      console.log(`[happy-mode-detector] Verbosity: ${config.verbosity}`);
+    } else {
+      console.log('[happy-mode-detector] Happy mode not detected');
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[happy-mode-detector] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/happy-title-generator.template.js

@@ -0,0 +1,260 @@
+/**
+ * Happy Title Generator Hook
+ *
+ * Auto-generates session titles with format: "Issue #XX - Summary"
+ * Detects GitHub issue numbers from branch names.
+ * Notifies Happy daemon of title updates for mobile display.
+ *
+ * Event: UserPromptSubmit
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  rate_limit_ms: 30000,           // Throttle title updates to once per 30 sec
+  max_summary_words: 4,           // Maximum words in title summary
+  issue_pattern: 'issue-(\\d+)',  // Regex to extract issue number from branch
+  common_prefixes: [              // Prefixes to remove from summaries
+    'implement', 'add', 'fix', 'update', 'create',
+    'refactor', 'build', 'remove', 'optimize', 'improve'
+  ],
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const STATE_PATH = path.join(process.cwd(), '.claude', 'config', 'title-generator-state.json');
+const HAPPY_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.happy', 'daemon.state.json');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.title_generator || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Load state
+ */
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_PATH)) {
+      return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // Return fresh state
+  }
+  return {
+    last_update: 0,
+    current_title: null,
+    issue_number: null,
+  };
+}
+
+/**
+ * Save state
+ */
+function saveState(state) {
+  try {
+    const dir = path.dirname(STATE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+    return branch;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Extract issue number from branch name
+ */
+function extractIssueNumber(branch, config) {
+  if (!branch) return null;
+
+  try {
+    const pattern = new RegExp(config.issue_pattern, 'i');
+    const match = branch.match(pattern);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+  } catch (e) {
+    // Invalid regex pattern
+  }
+
+  // Try common patterns as fallback
+  const fallbackPatterns = [
+    /issue-(\d+)/i,
+    /(\d+)-/,
+    /#(\d+)/,
+  ];
+
+  for (const pattern of fallbackPatterns) {
+    const match = branch.match(pattern);
+    if (match && match[1]) {
+      return parseInt(match[1], 10);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Generate summary from user prompt
+ */
+function generateSummary(prompt, config) {
+  if (!prompt) return 'New Session';
+
+  // Clean the prompt
+  let summary = prompt.trim();
+
+  // Remove common prefixes
+  const prefixPattern = new RegExp(`^(${config.common_prefixes.join('|')})\\s+`, 'i');
+  summary = summary.replace(prefixPattern, '');
+
+  // Take first N words
+  const words = summary.split(/\s+/).slice(0, config.max_summary_words);
+  summary = words.join(' ');
+
+  // Capitalize first letter
+  if (summary.length > 0) {
+    summary = summary.charAt(0).toUpperCase() + summary.slice(1);
+  }
+
+  // Truncate if too long
+  if (summary.length > 50) {
+    summary = summary.substring(0, 47) + '...';
+  }
+
+  return summary || 'New Session';
+}
+
+/**
+ * Format title with issue number
+ */
+function formatTitle(issueNumber, summary, branch) {
+  let title = '';
+
+  if (issueNumber) {
+    title = `Issue #${issueNumber} - ${summary}`;
+  } else {
+    title = summary;
+  }
+
+  // Add branch info if available
+  if (branch && branch !== 'main' && branch !== 'master') {
+    const shortBranch = branch.length > 20 ? branch.substring(0, 17) + '...' : branch;
+    title = `${title} | ${shortBranch}`;
+  }
+
+  return title;
+}
+
+/**
+ * Notify Happy daemon of title update
+ */
+function notifyHappyDaemon(title) {
+  try {
+    if (!fs.existsSync(HAPPY_STATE_PATH)) {
+      return false; // Happy daemon not running
+    }
+
+    const happyState = JSON.parse(fs.readFileSync(HAPPY_STATE_PATH, 'utf8'));
+
+    // Update session title in daemon state
+    happyState.current_session = happyState.current_session || {};
+    happyState.current_session.title = title;
+    happyState.current_session.updated_at = new Date().toISOString();
+
+    // Write atomically using temp file
+    const tempPath = HAPPY_STATE_PATH + '.tmp';
+    fs.writeFileSync(tempPath, JSON.stringify(happyState, null, 2), 'utf8');
+    fs.renameSync(tempPath, HAPPY_STATE_PATH);
+
+    return true;
+  } catch (e) {
+    return false; // Silent failure - daemon may not be running
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function happyTitleGenerator(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    const config = loadConfig();
+    const state = loadState();
+    const now = Date.now();
+
+    // Rate limiting - don't update too frequently
+    if (state.last_update && (now - state.last_update) < config.rate_limit_ms) {
+      return approve();
+    }
+
+    // Parse hook input for user prompt
+    let userPrompt = '';
+    try {
+      const input = JSON.parse(process.env.CLAUDE_HOOK_INPUT || '{}');
+      userPrompt = input.prompt || input.message || '';
+    } catch (e) {
+      // No prompt available
+    }
+
+    // Get git context
+    const branch = getCurrentBranch();
+    const issueNumber = extractIssueNumber(branch, config);
+
+    // Generate title components
+    const summary = generateSummary(userPrompt, config);
+    const title = formatTitle(issueNumber, summary, branch);
+
+    // Update state
+    state.last_update = now;
+    state.current_title = title;
+    state.issue_number = issueNumber;
+    saveState(state);
+
+    // Notify Happy daemon (if running)
+    const notified = notifyHappyDaemon(title);
+
+    if (notified) {
+      console.log(`[happy-title-generator] Title updated: ${title}`);
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[happy-title-generator] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/issue-completion-detector.template.js

@@ -0,0 +1,205 @@
+/**
+ * Issue Completion Detector Hook
+ *
+ * Detects natural language indicators of task/issue completion.
+ * Auto-triggers deployment pipeline when completion phrases are detected.
+ * Integrates with GitHub to update issue status.
+ *
+ * Event: UserPromptSubmit
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  enabled: true,
+  auto_deploy: false,                    // Auto-trigger deployment on completion
+  update_github: true,                   // Update GitHub issue status
+  completion_phrases: [
+    'task complete',
+    'task completed',
+    'issue resolved',
+    'issue fixed',
+    'done with this',
+    'finished implementing',
+    'ready for review',
+    'ready to merge',
+    'all tests pass',
+    'implementation complete',
+  ],
+  deploy_command: '/deploy-full',        // Command to trigger on completion
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const STATE_PATH = path.join(process.cwd(), '.claude', 'config', 'completion-detector-state.json');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.issue_completion || {}) };
+    }
+  } catch (e) {
+    // Use defaults
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Load state
+ */
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_PATH)) {
+      return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // Fresh state
+  }
+  return {
+    last_detection: null,
+    completions_detected: 0,
+    deployments_triggered: 0,
+  };
+}
+
+/**
+ * Save state
+ */
+function saveState(state) {
+  try {
+    const dir = path.dirname(STATE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2), 'utf8');
+  } catch (e) {
+    // Silent
+  }
+}
+
+/**
+ * Check if message contains completion phrase
+ */
+function detectCompletion(message, config) {
+  if (!message) return null;
+
+  const lowerMessage = message.toLowerCase();
+
+  for (const phrase of config.completion_phrases) {
+    if (lowerMessage.includes(phrase.toLowerCase())) {
+      return phrase;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get current issue number from branch
+ */
+function getCurrentIssue() {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const match = branch.match(/issue-(\d+)/i) || branch.match(/(\d+)-/);
+    if (match) {
+      return parseInt(match[1], 10);
+    }
+  } catch (e) {
+    // Not in git repo or error
+  }
+  return null;
+}
+
+/**
+ * Update GitHub issue (if gh CLI available)
+ */
+function updateGitHubIssue(issueNumber, message) {
+  try {
+    // Add comment about completion
+    execSync(`gh issue comment ${issueNumber} --body "Task marked as complete via Claude CLI"`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10000,
+    });
+
+    console.log(`[issue-completion-detector] Updated GitHub issue #${issueNumber}`);
+    return true;
+  } catch (e) {
+    console.log(`[issue-completion-detector] Could not update GitHub issue: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function issueCompletionDetector(context) {
+  const approve = () => ({ continue: true });
+
+  try {
+    const config = loadConfig();
+
+    if (!config.enabled) {
+      return approve();
+    }
+
+    // Parse hook input
+    let userMessage = '';
+    try {
+      const input = JSON.parse(process.env.CLAUDE_HOOK_INPUT || '{}');
+      userMessage = input.prompt || input.message || '';
+    } catch (e) {
+      return approve();
+    }
+
+    // Check for completion phrase
+    const detectedPhrase = detectCompletion(userMessage, config);
+
+    if (!detectedPhrase) {
+      return approve();
+    }
+
+    // Completion detected!
+    console.log(`[issue-completion-detector] Completion detected: "${detectedPhrase}"`);
+
+    const state = loadState();
+    state.last_detection = new Date().toISOString();
+    state.completions_detected++;
+
+    // Get current issue
+    const issueNumber = getCurrentIssue();
+
+    // Update GitHub if configured
+    if (config.update_github && issueNumber) {
+      updateGitHubIssue(issueNumber, userMessage);
+    }
+
+    // Log deployment suggestion
+    if (config.auto_deploy) {
+      console.log(`[issue-completion-detector] Auto-deploy enabled. Suggested: ${config.deploy_command}`);
+      state.deployments_triggered++;
+    } else {
+      console.log(`[issue-completion-detector] Consider running: ${config.deploy_command}`);
+    }
+
+    saveState(state);
+
+    return approve();
+  } catch (error) {
+    console.error(`[issue-completion-detector] Error: ${error.message}`);
+    return approve();
+  }
+};