cc-dev-template 0.1.1

package/src/scripts/merge-settings.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * merge-settings.js - Merge configuration into ~/.claude/settings.json
+ *
+ * This utility script safely merges configuration into the Claude Code
+ * settings.json file, handling all edge cases:
+ * - File doesn't exist (creates it)
+ * - Preserves all existing configuration
+ * - Special handling for hooks.PostToolUse arrays (prevents duplicates)
+ * - Simple merge for other top-level properties
+ *
+ * Usage:
+ *   node ~/.claude/scripts/merge-settings.js <settings-file> <config-file>
+ *
+ * Arguments:
+ *   settings-file   Path to the settings.json file (e.g., ~/.claude/settings.json)
+ *   config-file     Path to a JSON file containing the configuration to merge
+ *
+ * Config format examples:
+ *
+ *   Hook configuration:
+ *   {
+ *     "hooks": {
+ *       "PostToolUse": [
+ *         {
+ *           "matcher": "Edit|Write",
+ *           "hooks": [{ "type": "command", "command": "..." }]
+ *         }
+ *       ]
+ *     }
+ *   }
+ *
+ *   Status line configuration:
+ *   {
+ *     "statusLine": {
+ *       "type": "command",
+ *       "command": "node ~/.claude/scripts/statusline.js"
+ *     }
+ *   }
+ *
+ * Exit codes:
+ *   0 = Success (settings merged or already correct)
+ *   1 = Error (file I/O or JSON parsing failed)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract command strings from a hooks array (handles both string and object formats)
+ * @param {Array} hooks - Array of hook definitions (strings or objects with command property)
+ * @returns {Set<string>} - Set of command strings
+ */
+function extractCommands(hooks) {
+  const commands = new Set();
+  if (!hooks) return commands;
+
+  for (const hook of hooks) {
+    if (typeof hook === 'string') {
+      commands.add(hook);
+    } else if (hook && typeof hook.command === 'string') {
+      commands.add(hook.command);
+    }
+  }
+  return commands;
+}
+
+/**
+ * Merge hooks configuration with duplicate prevention
+ * @param {object} existingHooks - The existing hooks object
+ * @param {object} newHooks - The new hooks to merge
+ * @returns {object} - The merged hooks object
+ */
+function mergeHooks(existingHooks, newHooks) {
+  const result = { ...existingHooks };
+
+  for (const [hookType, hookArray] of Object.entries(newHooks)) {
+    if (!Array.isArray(hookArray)) continue;
+
+    if (!result[hookType]) {
+      result[hookType] = [];
+    }
+
+    // For each new hook, check if it already exists before adding
+    for (const newHook of hookArray) {
+      const newCommands = extractCommands(newHook.hooks);
+
+      const hookExists = result[hookType].some((existingHook) => {
+        if (existingHook.matcher !== newHook.matcher) return false;
+
+        const existingCommands = extractCommands(existingHook.hooks);
+        for (const cmd of newCommands) {
+          if (existingCommands.has(cmd)) return true;
+        }
+        return false;
+      });
+
+      if (!hookExists) {
+        result[hookType].push(newHook);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Merge configuration into existing settings
+ * @param {object} existing - The existing settings object
+ * @param {object} newConfig - The new configuration to merge
+ * @returns {object} - The merged settings object
+ */
+function mergeSettings(existing, newConfig) {
+  const result = { ...existing };
+
+  for (const [key, value] of Object.entries(newConfig)) {
+    if (key === 'hooks' && typeof value === 'object') {
+      // Special handling for hooks - merge arrays with duplicate prevention
+      result.hooks = mergeHooks(result.hooks || {}, value);
+    } else {
+      // For other properties, simply overwrite (or add if new)
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Main function to merge settings
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    console.error('Usage: node merge-settings.js <settings-file> <config-file>');
+    process.exit(1);
+  }
+
+  const settingsPath = args[0];
+  const configPath = args[1];
+
+  try {
+    // Read configuration to merge
+    let config;
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(configContent);
+    } catch (error) {
+      console.error(`Error reading config from ${configPath}: ${error.message}`);
+      process.exit(1);
+    }
+
+    // Read existing settings or create empty object
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+        settings = JSON.parse(settingsContent);
+      } catch (error) {
+        console.error(`Error parsing existing settings at ${settingsPath}: ${error.message}`);
+        process.exit(1);
+      }
+    }
+
+    // Merge the configurations
+    const merged = mergeSettings(settings, config);
+
+    // Ensure directory exists
+    const dir = path.dirname(settingsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Write merged settings back to file
+    fs.writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+
+    console.log(`✓ Settings merged successfully: ${settingsPath}`);
+    process.exit(0);
+  } catch (error) {
+    console.error(`Error merging settings: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/scripts/statusline-config.json

@@ -0,0 +1,7 @@
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node ~/.claude/scripts/statusline.js",
+    "padding": 0
+  }
+}

package/src/scripts/statusline.js

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+
+/**
+ * Custom Status Line for Claude Code
+ *
+ * Displays project status in lines:
+ * - Directory name + Git branch + status (combined)
+ * - Context window usage bar with percentage and tokens
+ *
+ * Input: JSON on stdin with transcript_path
+ * Output: Formatted status to stdout
+ */
+
+const { existsSync, readFileSync, readdirSync, statSync } = require('fs');
+const { join, basename } = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Get model token limit based on model ID
+ */
+function getModelTokenLimit(modelId) {
+  // Claude model context windows
+  if (modelId.includes('claude-3-5-sonnet') || modelId.includes('claude-sonnet-4')) {
+    return 200000;
+  }
+  if (modelId.includes('claude-3-opus')) {
+    return 200000;
+  }
+  if (modelId.includes('claude-3-haiku')) {
+    return 200000;
+  }
+  // Default fallback
+  return 200000;
+}
+
+/**
+ * Calculate context window usage from transcript
+ * Uses MOST RECENT message only (each message already reports full context)
+ */
+function calculateTokenUsage(transcriptPath) {
+  try {
+    if (!existsSync(transcriptPath)) {
+      return null;
+    }
+
+    const content = readFileSync(transcriptPath, 'utf-8');
+    const lines = content.trim().split('\n');
+
+    // Parse all messages
+    const messages = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+    }
+
+    // Find most recent main-chain message with usage data
+    const mainChainMessages = messages.filter((m) => m.isSidechain === false);
+    if (mainChainMessages.length === 0) {
+      return null;
+    }
+
+    // Sort by timestamp descending (most recent first)
+    mainChainMessages.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+
+    // Find first message with usage data
+    let contextLength = 0;
+    let modelId = '';
+
+    for (const msg of mainChainMessages) {
+      if (msg.message?.usage) {
+        const usage = msg.message.usage;
+        // Context = input + cache_read + cache_creation
+        // (each message already reports FULL context at that point)
+        contextLength =
+          (usage.input_tokens || 0) +
+          (usage.cache_read_input_tokens || 0) +
+          (usage.cache_creation_input_tokens || 0);
+        modelId = msg.message.model || '';
+        break; // Stop after most recent usage!
+      }
+    }
+
+    const limit = getModelTokenLimit(modelId);
+    const percentage = Math.min(100, Math.round((contextLength / limit) * 100));
+
+    return { used: contextLength, limit, percentage };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format number as K (e.g., 84000 -> "084K")
+ */
+function formatTokens(tokens) {
+  const k = Math.floor(tokens / 1000);
+  return k.toString().padStart(3, '0') + 'K';
+}
+
+/**
+ * Generate smooth bar using Braille characters (8 levels per character)
+ */
+function generateBar(percentage, width = 20) {
+  const brailleSteps = ['⠀', '⡀', '⣀', '⣄', '⣤', '⣦', '⣶', '⣷', '⣿'];
+
+  const totalSteps = width * 8; // 8 sub-steps per character
+  const filledSteps = Math.round((percentage / 100) * totalSteps);
+
+  let bar = '';
+  for (let i = 0; i < width; i++) {
+    const charSteps = filledSteps - i * 8;
+    if (charSteps >= 8) {
+      bar += '⣿'; // Fully filled
+    } else if (charSteps > 0) {
+      bar += brailleSteps[charSteps]; // Partially filled
+    } else {
+      bar += '⠀'; // Empty
+    }
+  }
+
+  return bar;
+}
+
+/**
+ * Get greyscale intensity based on token percentage
+ */
+function getContextGreyscale(percentage) {
+  // Use ANSI 256 colors for greyscale (232-255 are grey shades)
+  // Darker grey for low usage, lighter/white for high usage
+  if (percentage >= 90) return '\x1b[38;5;255m'; // Bright white - critical
+  if (percentage >= 75) return '\x1b[38;5;250m'; // Light grey - warning
+  if (percentage >= 50) return '\x1b[38;5;245m'; // Medium grey
+  return '\x1b[38;5;240m'; // Dark grey - safe
+}
+
+/**
+ * Count files in a directory recursively
+ */
+function countFilesInDirectory(dirPath) {
+  try {
+    let count = 0;
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        count += countFilesInDirectory(fullPath);
+      } else {
+        count++;
+      }
+    }
+
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Get git status counts
+ */
+function getGitStatus(projectDir) {
+  try {
+    const output = execSync('git status --short', {
+      cwd: projectDir,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+    });
+
+    const counts = { modified: 0, added: 0, deleted: 0, untracked: 0 };
+
+    for (const line of output.split('\n')) {
+      if (!line.trim()) continue;
+
+      const status = line.substring(0, 2);
+      if (status.includes('M')) counts.modified++;
+      if (status.includes('A')) counts.added++;
+      if (status.includes('D')) counts.deleted++;
+
+      // Handle untracked files/directories
+      if (status.includes('?')) {
+        const filePath = line.substring(3).trim(); // Remove '?? ' prefix
+        const fullPath = join(projectDir, filePath);
+
+        try {
+          const stats = statSync(fullPath);
+          if (stats.isDirectory()) {
+            // Count all files in the directory
+            counts.untracked += countFilesInDirectory(fullPath);
+          } else {
+            // Single file
+            counts.untracked++;
+          }
+        } catch {
+          // If stat fails, count as 1
+          counts.untracked++;
+        }
+      }
+    }
+
+    return counts;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format git status counts as string
+ */
+function formatGitStatus(counts) {
+  const parts = [];
+
+  if (counts.modified > 0) parts.push(`${counts.modified}M`);
+  if (counts.added > 0) parts.push(`${counts.added}A`);
+  if (counts.deleted > 0) parts.push(`${counts.deleted}D`);
+  if (counts.untracked > 0) parts.push(`${counts.untracked}U`);
+
+  return parts.length > 0 ? `± ${parts.join('/')}` : '';
+}
+
+/**
+ * Get current git branch name
+ */
+function getGitBranch(projectDir) {
+  try {
+    const branch = execSync('git branch --show-current', {
+      cwd: projectDir,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+    }).trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main function
+ */
+function main() {
+  try {
+    // Read input from stdin
+    let input = readFileSync(0, 'utf-8');
+
+    // Try to parse JSON - if it fails due to Windows path escaping, attempt to fix it
+    let data;
+    try {
+      data = JSON.parse(input);
+    } catch {
+      // Windows path escaping issue - replace backslashes with forward slashes
+      input = input.replace(/\\\\/g, '/');
+      data = JSON.parse(input);
+    }
+
+    // Normalize all Windows paths to forward slashes (Node.js handles both on Windows)
+    if (data.workspace) {
+      data.workspace.project_dir = data.workspace.project_dir.replace(/\\/g, '/');
+      data.workspace.current_dir = data.workspace.current_dir.replace(/\\/g, '/');
+    }
+
+    // ANSI color codes
+    const DIM_GREY = '\x1b[38;5;245m';
+    const RESET = '\x1b[0m';
+
+    // Get token usage from transcript (use transcript_path directly from input)
+    let tokenData = null;
+    if (data.transcript_path) {
+      tokenData = calculateTokenUsage(data.transcript_path);
+    }
+
+    // Generate context display
+    let ctxDisplay = 'CTX: [NO DATA]';
+    if (tokenData) {
+      const bar = generateBar(tokenData.percentage, 20);
+      const usedTokens = formatTokens(tokenData.used);
+      const limitTokens = formatTokens(tokenData.limit);
+      const pct = tokenData.percentage.toString().padStart(2, ' ');
+
+      // Get greyscale intensity for this percentage
+      const greyColor = getContextGreyscale(tokenData.percentage);
+
+      // Apply greyscale to just the bar and percentage, then return to dim grey for rest
+      ctxDisplay = `CTX: ${greyColor}[${bar}] ${pct}%${DIM_GREY} | ${usedTokens}/${limitTokens}`;
+    }
+
+    // Get git information
+    const gitBranch = getGitBranch(data.workspace.project_dir);
+    const gitStatus = getGitStatus(data.workspace.project_dir);
+    const gitStatusStr = gitStatus ? formatGitStatus(gitStatus) : '';
+
+    // Multi-line bordered box format
+    const width = 56;
+
+    // Top border with model name (add 2 to match content line width: ║ + space + 56 + space + ║ = 60)
+    const modelName = data.model.display_name.toUpperCase();
+    const labelWidth = modelName.length + 2; // +2 for brackets
+    const topBorder = `${DIM_GREY}╔═[${modelName}]${'═'.repeat(width - labelWidth + 1)}╗${RESET}`;
+
+    // Line 0: Directory + Git branch + status (padded to width)
+    const rawDirName = basename(data.workspace.project_dir).toUpperCase();
+    let line0Content = '';
+
+    if (gitBranch) {
+      // Calculate available space: total width - "DIR: " - " | " - git status
+      const dirPrefix = 'DIR: ';
+      const separator = ' | ';
+      const gitStatusSpace = gitStatusStr ? ` ${gitStatusStr}` : '';
+
+      // Reserve space for branch indicator and git status
+      const branchSuffix = ' ⎇';
+      const reservedSpace =
+        dirPrefix.length + separator.length + branchSuffix.length + gitStatusSpace.length;
+      const availableSpace = width - reservedSpace;
+
+      // Split available space between directory and branch (favor branch slightly)
+      const maxDirLen = Math.floor(availableSpace * 0.4);
+      const maxBranchLen = availableSpace - maxDirLen;
+
+      const dirName =
+        rawDirName.length > maxDirLen ? rawDirName.substring(0, maxDirLen - 3) + '...' : rawDirName;
+
+      const displayBranch =
+        gitBranch.length > maxBranchLen
+          ? gitBranch.substring(0, maxBranchLen - 3) + '...'
+          : gitBranch;
+
+      line0Content = `${dirPrefix}${dirName}${separator}${displayBranch.toUpperCase()}${branchSuffix}${gitStatusSpace}`;
+    } else {
+      // No git info, just show directory
+      const maxDirLen = 20;
+      const dirName =
+        rawDirName.length > maxDirLen ? rawDirName.substring(0, maxDirLen - 3) + '...' : rawDirName;
+      line0Content = `DIR: ${dirName}`;
+    }
+
+    const plainLine0 = line0Content.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding0 = width - plainLine0.length;
+    const paddedLine0 = line0Content + ' '.repeat(Math.max(0, padding0));
+    const line0 = `${DIM_GREY}║ ${paddedLine0} ║${RESET}`;
+
+    // Line 1: Context bar (padded to width)
+    const plainCtx = ctxDisplay.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding1 = width - plainCtx.length;
+    const paddedCtx = ctxDisplay + ' '.repeat(Math.max(0, padding1));
+    const line1 = `${DIM_GREY}║ ${paddedCtx} ║${RESET}`;
+
+    // Bottom border (add 2 to match content line width)
+    const bottomBorder = `${DIM_GREY}╚${'═'.repeat(width + 2)}╝${RESET}`;
+
+    console.log(`${topBorder}\n${line0}\n${line1}\n${bottomBorder}`);
+  } catch (error) {
+    // Log error for debugging (goes to stderr, not visible in status line)
+    console.error(`Status line error: ${error.message}`);
+    // Fallback to simple status on any error
+    console.log('—');
+  }
+}
+
+main();

package/src/scripts/validate-yaml.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+/**
+ * validate-yaml.js - Validate YAML syntax in files
+ *
+ * This script validates YAML files after they are created or modified through Claude Code's
+ * Edit or Write tools. It's invoked by the PostToolUse hook system with JSON input via stdin
+ * containing the file path that was just modified.
+ *
+ * Usage:
+ *   echo '{"tool_input":{"file_path":"/path/to/file.yaml"}}' | node validate-yaml.js
+ *
+ * Input format (JSON via stdin):
+ *   {
+ *     "tool_input": {
+ *       "file_path": "/absolute/path/to/file.yaml"
+ *     }
+ *   }
+ *
+ * Exit codes:
+ *   0 - File is valid YAML or not a YAML file (silent success)
+ *   2 - File is invalid YAML (parsing error written to stderr)
+ *
+ * Behavior:
+ *   - Non-YAML files (.yaml and .yml extensions) pass through silently with exit 0
+ *   - Valid YAML files produce no output and exit 0
+ *   - Invalid YAML files produce parsing error on stderr and exit 2
+ *
+ * Dependencies:
+ *   - js-yaml (for YAML parsing)
+ *   - Node.js built-ins (fs, path)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Read JSON from stdin and extract file_path
+ * @returns {Promise<string | null>} - The file path from tool_input, or null if invalid
+ */
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      data += chunk;
+    });
+
+    process.stdin.on('end', () => {
+      try {
+        const parsed = JSON.parse(data);
+        const filePath = parsed?.tool_input?.file_path;
+        resolve(filePath || null);
+      } catch (error) {
+        // If we can't parse the input, still exit cleanly - don't interrupt the user's work
+        resolve(null);
+      }
+    });
+
+    process.stdin.on('error', () => {
+      // If there's an issue reading stdin, exit cleanly
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Check if a file has a YAML extension
+ * @param {string} filePath - The file path to check
+ * @returns {boolean} - True if the file ends with .yaml or .yml
+ */
+function isYamlFile(filePath) {
+  return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
+}
+
+/**
+ * Validate YAML syntax by attempting to parse the file
+ * @param {string} filePath - The absolute path to the YAML file
+ * @returns {{ valid: boolean, error?: string }} - Validation result with optional error message
+ */
+function validateYaml(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    yaml.load(content);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Main execution - validate YAML file from tool input
+ */
+async function main() {
+  const filePath = await readStdin();
+
+  // If we couldn't extract a file path, exit silently
+  if (!filePath) {
+    process.exit(0);
+  }
+
+  // If it's not a YAML file, pass through silently
+  if (!isYamlFile(filePath)) {
+    process.exit(0);
+  }
+
+  // Validate the YAML file
+  const result = validateYaml(filePath);
+
+  if (result.valid) {
+    // Valid YAML - silent success
+    process.exit(0);
+  } else {
+    // Invalid YAML - report error to stderr
+    console.error(`YAML validation error in ${filePath}:\n${result.error}`);
+    process.exit(2);
+  }
+}
+
+main().catch(() => {
+  // If anything goes wrong, exit silently to avoid disrupting the user's workflow
+  process.exit(0);
+});

package/src/scripts/yaml-validation-hook.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ~/.claude/scripts/validate-yaml.js"
+          }
+        ]
+      }
+    ]
+  }
+}