@ngxtm/devkit 2.1.0 → 3.0.0

package/templates/base/hooks/lib/ck-paths.cjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * ClaudeKit Paths - Centralized path constants for all temporary/runtime files
+ *
+ * All ClaudeKit temp files consolidated under /tmp/ck/ namespace for:
+ * - Cleaner /tmp directory (single namespace)
+ * - Easier cleanup (rm -rf /tmp/ck/)
+ * - Debugging (all state in one place)
+ * - No collisions with other tools
+ *
+ * Fixes:
+ * - #177: Race condition from shared global state file
+ * - #178: Scattered temp files consolidation
+ *
+ * @module ck-paths
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+// Root directory for all ClaudeKit temp files
+const CK_TMP_DIR = path.join(os.tmpdir(), 'ck');
+
+// Session-specific marker files (per-session, no race conditions)
+const MARKERS_DIR = path.join(CK_TMP_DIR, 'markers');
+
+// Global calibration data (shared by design - records compact thresholds)
+const CALIBRATION_PATH = path.join(CK_TMP_DIR, 'calibration.json');
+
+// Debug logs directory
+const DEBUG_DIR = path.join(CK_TMP_DIR, 'debug');
+
+/**
+ * Ensure directory exists
+ * @param {string} dirPath - Directory path to create
+ */
+function ensureDir(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  } catch (err) {
+    // Silent fail - non-critical, but log for debugging
+    if (process.env.CK_DEBUG) {
+      console.error(`[CK] Failed to create ${dirPath}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Get marker file path for a session
+ * @param {string} sessionId - Session ID
+ * @returns {string} Full path to marker file
+ */
+function getMarkerPath(sessionId) {
+  return path.join(MARKERS_DIR, `${sessionId}.json`);
+}
+
+/**
+ * Get debug log path for a session
+ * @param {string} sessionId - Session ID
+ * @returns {string} Full path to debug log
+ */
+function getDebugLogPath(sessionId) {
+  return path.join(DEBUG_DIR, `${sessionId}.log`);
+}
+
+/**
+ * Initialize ClaudeKit temp directories
+ * Call this at startup to ensure directories exist
+ */
+function initDirs() {
+  ensureDir(CK_TMP_DIR);
+  ensureDir(MARKERS_DIR);
+  ensureDir(DEBUG_DIR);
+}
+
+/**
+ * Clean up all ClaudeKit temp files
+ * Useful for testing or manual cleanup
+ */
+function cleanAll() {
+  try {
+    if (fs.existsSync(CK_TMP_DIR)) {
+      fs.rmSync(CK_TMP_DIR, { recursive: true, force: true });
+    }
+  } catch (err) {
+    // Silent fail
+  }
+}
+
+module.exports = {
+  // Directories
+  CK_TMP_DIR,
+  MARKERS_DIR,
+  DEBUG_DIR,
+
+  // Files
+  CALIBRATION_PATH,
+
+  // Helpers
+  ensureDir,
+  getMarkerPath,
+  getDebugLogPath,
+  initDirs,
+  cleanAll
+};

package/templates/base/hooks/lib/colors.cjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * ANSI Terminal Colors - Cross-platform color support for statusline
+ * Supports NO_COLOR, FORCE_COLOR, COLORTERM auto-detection
+ * @module colors
+ */
+
+// ANSI escape codes (8-color basic palette)
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const MAGENTA = '\x1b[35m';
+const CYAN = '\x1b[36m';
+
+// Detect color support at module load (cached)
+// Claude Code statusline runs via pipe but output displays in TTY - default to true
+const shouldUseColor = (() => {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  // Default true for statusline context (Claude Code handles TTY display)
+  return true;
+})();
+
+// Detect 256-color support via COLORTERM
+const has256Color = (() => {
+  const ct = process.env.COLORTERM;
+  return ct === 'truecolor' || ct === '24bit' || ct === '256color';
+})();
+
+/**
+ * Wrap text with ANSI color code
+ * @param {string} text - Text to colorize
+ * @param {string} code - ANSI escape code
+ * @returns {string} Colorized text or plain text if colors disabled
+ */
+function colorize(text, code) {
+  if (!shouldUseColor) return String(text);
+  return `${code}${text}${RESET}`;
+}
+
+function green(text) { return colorize(text, GREEN); }
+function yellow(text) { return colorize(text, YELLOW); }
+function red(text) { return colorize(text, RED); }
+function cyan(text) { return colorize(text, CYAN); }
+function magenta(text) { return colorize(text, MAGENTA); }
+function dim(text) { return colorize(text, DIM); }
+
+/**
+ * Get color code based on context percentage threshold
+ * @param {number} percent - Context usage percentage (0-100)
+ * @returns {string} ANSI color code
+ */
+function getContextColor(percent) {
+  if (percent >= 85) return RED;
+  if (percent >= 70) return YELLOW;
+  return GREEN;
+}
+
+/**
+ * Generate colored progress bar for context window
+ * Uses ▰▱ characters (smooth horizontal rectangles) for consistent rendering
+ * @param {number} percent - Usage percentage (0-100)
+ * @param {number} width - Bar width in characters (default 12)
+ * @returns {string} Unicode progress bar with threshold-based colors
+ */
+function coloredBar(percent, width = 12) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round((clamped / 100) * width);
+  const empty = width - filled;
+
+  if (!shouldUseColor) {
+    return '▰'.repeat(filled) + '▱'.repeat(empty);
+  }
+
+  const color = getContextColor(percent);
+  return `${color}${'▰'.repeat(filled)}${DIM}${'▱'.repeat(empty)}${RESET}`;
+}
+
+module.exports = {
+  RESET,
+  green,
+  yellow,
+  red,
+  cyan,
+  magenta,
+  dim,
+  getContextColor,
+  coloredBar,
+  shouldUseColor,
+  has256Color
+};

package/templates/base/hooks/lib/config-counter.cjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+'use strict';
+
+// Config Counter - Count CLAUDE.md, rules, MCPs, hooks across user and project scopes
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getMcpServerNames(filePath) {
+  if (!fs.existsSync(filePath)) return new Set();
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const config = JSON.parse(content);
+    if (config.mcpServers && typeof config.mcpServers === 'object') {
+      return new Set(Object.keys(config.mcpServers));
+    }
+  } catch {
+    // Silent fail
+  }
+  return new Set();
+}
+
+function countMcpServersInFile(filePath, excludeFrom) {
+  const servers = getMcpServerNames(filePath);
+  if (excludeFrom) {
+    const exclude = getMcpServerNames(excludeFrom);
+    for (const name of exclude) {
+      servers.delete(name);
+    }
+  }
+  return servers.size;
+}
+
+function countHooksInFile(filePath) {
+  if (!fs.existsSync(filePath)) return 0;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const config = JSON.parse(content);
+    if (config.hooks && typeof config.hooks === 'object') {
+      return Object.keys(config.hooks).length;
+    }
+  } catch {
+    // Silent fail
+  }
+  return 0;
+}
+
+function countRulesInDir(rulesDir, depth = 0) {
+  // Depth limit prevents symlink loops and excessive recursion
+  if (depth > 5 || !fs.existsSync(rulesDir)) return 0;
+  let count = 0;
+  try {
+    const entries = fs.readdirSync(rulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      // Skip symlinks to prevent loops
+      if (entry.isSymbolicLink()) continue;
+      const fullPath = path.join(rulesDir, entry.name);
+      if (entry.isDirectory()) {
+        count += countRulesInDir(fullPath, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        count++;
+      }
+    }
+  } catch {
+    // Silent fail
+  }
+  return count;
+}
+
+function countConfigs(cwd) {
+  let claudeMdCount = 0, rulesCount = 0, mcpCount = 0, hooksCount = 0;
+  const homeDir = os.homedir();
+  const claudeDir = path.join(homeDir, '.claude');
+
+  // User scope
+  if (fs.existsSync(path.join(claudeDir, 'CLAUDE.md'))) claudeMdCount++;
+  rulesCount += countRulesInDir(path.join(claudeDir, 'rules'));
+  const userSettings = path.join(claudeDir, 'settings.json');
+  mcpCount += countMcpServersInFile(userSettings);
+  hooksCount += countHooksInFile(userSettings);
+  mcpCount += countMcpServersInFile(path.join(homeDir, '.claude.json'), userSettings);
+
+  // Project scope
+  if (cwd) {
+    if (fs.existsSync(path.join(cwd, 'CLAUDE.md'))) claudeMdCount++;
+    if (fs.existsSync(path.join(cwd, 'CLAUDE.local.md'))) claudeMdCount++;
+    if (fs.existsSync(path.join(cwd, '.claude', 'CLAUDE.md'))) claudeMdCount++;
+    if (fs.existsSync(path.join(cwd, '.claude', 'CLAUDE.local.md'))) claudeMdCount++;
+    rulesCount += countRulesInDir(path.join(cwd, '.claude', 'rules'));
+    mcpCount += countMcpServersInFile(path.join(cwd, '.mcp.json'));
+    const projectSettings = path.join(cwd, '.claude', 'settings.json');
+    mcpCount += countMcpServersInFile(projectSettings);
+    hooksCount += countHooksInFile(projectSettings);
+    const localSettings = path.join(cwd, '.claude', 'settings.local.json');
+    mcpCount += countMcpServersInFile(localSettings);
+    hooksCount += countHooksInFile(localSettings);
+  }
+
+  return { claudeMdCount, rulesCount, mcpCount, hooksCount };
+}
+
+module.exports = { countConfigs, getMcpServerNames, countMcpServersInFile, countHooksInFile, countRulesInDir };