thanh-kit 2.5.0 → 2.5.2

package/templates/hooks/lib/ck-config-utils.cjs

@@ -38,6 +38,9 @@ const DEFAULT_CONFIG = {
     docs: 'docs',
     plans: 'plans'
   },
+  docs: {
+    maxLoc: 800  // Maximum lines of code per doc file before warning
+  },
   locale: {
     thinkingLanguage: null,  // Language for reasoning (e.g., "en" for precision)
     responseLanguage: null   // Language for user-facing output (e.g., "vi")
@@ -51,12 +54,35 @@ const DEFAULT_CONFIG = {
     packageManager: 'auto',
     framework: 'auto'
   },
-  assertions: []
+  skills: {
+    research: {
+      useGemini: true  // Toggle Gemini CLI usage in research skill
+    }
+  },
+  assertions: [],
+  statusline: 'full',
+  hooks: {
+    'session-init': true,
+    'subagent-init': true,
+    'dev-rules-reminder': true,
+    'usage-context-awareness': true,
+    'context-tracking': true,
+    'scout-block': true,
+    'privacy-block': true,
+    'post-edit-simplify-reminder': true,
+    'task-completed-handler': true,
+    'teammate-idle-handler': true
+  }
 };
 
 /**
  * Deep merge objects (source values override target, nested objects merged recursively)
  * Arrays are replaced entirely (not concatenated) to avoid duplicate entries
+ *
+ * IMPORTANT: Empty objects {} are treated as "inherit from parent", not "replace with empty".
+ * This allows global config to set hooks.foo: false and have it persist even when
+ * local config has hooks: {} (empty = inherit, not reset to defaults).
+ *
  * @param {Object} target - Base object
  * @param {Object} source - Object to merge (takes precedence)
  * @returns {Object} Merged object
@@ -75,7 +101,13 @@ function deepMerge(target, source) {
       result[key] = [...sourceVal];
     }
     // Objects: recurse (but not null)
+    // SKIP empty objects - treat {} as "inherit from parent"
     else if (sourceVal !== null && typeof sourceVal === 'object' && !Array.isArray(sourceVal)) {
+      // Empty object = inherit (don't override parent values)
+      if (Object.keys(sourceVal).length === 0) {
+        // Keep target value unchanged - empty source means "no override"
+        continue;
+      }
       result[key] = deepMerge(targetVal || {}, sourceVal);
     }
     // Primitives: source wins
@@ -217,22 +249,42 @@ function findMostRecentPlan(plansDir) {
   }
 }
 
+/**
+ * Default timeout for git commands (5 seconds)
+ * Prevents indefinite hangs on network mounts or corrupted repos
+ */
+const DEFAULT_EXEC_TIMEOUT_MS = 5000;
+
 /**
  * Safely execute shell command (internal helper)
  * SECURITY: Only accepts whitelisted git read commands
  * @param {string} cmd - Command to execute
+ * @param {Object} options - Execution options
+ * @param {string} options.cwd - Working directory (optional)
+ * @param {number} options.timeout - Timeout in ms (default: 5000)
  * @returns {string|null} Command output or null
  */
-function execSafe(cmd) {
+function execSafe(cmd, options = {}) {
   // Whitelist of safe read-only commands
-  const allowedCommands = ['git branch --show-current', 'git rev-parse --abbrev-ref HEAD'];
+  const allowedCommands = [
+    'git branch --show-current',
+    'git rev-parse --abbrev-ref HEAD',
+    'git rev-parse --show-toplevel'
+  ];
   if (!allowedCommands.includes(cmd)) {
     return null;
   }
 
+  const { cwd = undefined, timeout = DEFAULT_EXEC_TIMEOUT_MS } = options;
+
   try {
     return require('child_process')
-      .execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] })
+      .execSync(cmd, {
+        encoding: 'utf8',
+        timeout,
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe']
+      })
       .trim();
   } catch (e) {
     return null;
@@ -262,11 +314,15 @@ function resolvePlanPath(sessionId, config) {
       case 'session': {
         const state = readSessionState(sessionId);
         if (state?.activePlan) {
-          // Only use session state if CWD matches session origin (monorepo support)
-          if (state.sessionOrigin && state.sessionOrigin !== process.cwd()) {
-            break;  // Fall through to branch
+          // Issue #335: Handle both absolute and relative paths
+          // - Absolute paths (from updated set-active-plan.cjs): use as-is
+          // - Relative paths (legacy): resolve using sessionOrigin if available
+          let resolvedPath = state.activePlan;
+          if (!path.isAbsolute(resolvedPath) && state.sessionOrigin) {
+            // Resolve relative path using session origin directory
+            resolvedPath = path.join(state.sessionOrigin, resolvedPath);
           }
-          return { path: state.activePlan, resolvedBy: 'session' };
+          return { path: resolvedPath, resolvedBy: 'session' };
         }
         break;
       }
@@ -441,7 +497,8 @@ function loadConfig(options = {}) {
     // Build result with optional sections
     const result = {
       plan: merged.plan || DEFAULT_CONFIG.plan,
-      paths: merged.paths || DEFAULT_CONFIG.paths
+      paths: merged.paths || DEFAULT_CONFIG.paths,
+      docs: merged.docs || DEFAULT_CONFIG.docs
     };
 
     if (includeLocale) {
@@ -459,6 +516,12 @@ function loadConfig(options = {}) {
     // -1 = disabled (no injection, saves tokens)
     // 0-5 = inject corresponding level guidelines
     result.codingLevel = merged.codingLevel ?? -1;
+    // Skills configuration
+    result.skills = merged.skills || DEFAULT_CONFIG.skills;
+    // Hooks configuration
+    result.hooks = merged.hooks || DEFAULT_CONFIG.hooks;
+    // Statusline mode
+    result.statusline = merged.statusline || 'full';
 
     return sanitizeConfig(result, projectRoot);
   } catch (e) {
@@ -473,7 +536,11 @@ function getDefaultConfig(includeProject = true, includeAssertions = true, inclu
   const result = {
     plan: { ...DEFAULT_CONFIG.plan },
     paths: { ...DEFAULT_CONFIG.paths },
-    codingLevel: -1  // Default: disabled (no injection, saves tokens)
+    docs: { ...DEFAULT_CONFIG.docs },
+    codingLevel: -1,  // Default: disabled (no injection, saves tokens)
+    skills: { ...DEFAULT_CONFIG.skills },
+    hooks: { ...DEFAULT_CONFIG.hooks },
+    statusline: 'full'
   };
   if (includeLocale) {
     result.locale = { ...DEFAULT_CONFIG.locale };
@@ -489,10 +556,15 @@ function getDefaultConfig(includeProject = true, includeAssertions = true, inclu
 
 /**
  * Escape shell special characters for env file values
+ * Handles: backslash, double quote, dollar sign, backtick
  */
 function escapeShellValue(str) {
   if (typeof str !== 'string') return str;
-  return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$');
+  return str
+    .replace(/\\/g, '\\\\')   // Backslash first
+    .replace(/"/g, '\\"')     // Double quotes
+    .replace(/\$/g, '\\$')    // Dollar sign
+    .replace(/`/g, '\\`');    // Backticks (command substitution)
 }
 
 /**
@@ -514,19 +586,29 @@ function writeEnv(envFile, key, value) {
  * @param {string|null} resolvedBy - How plan was resolved ('session'|'branch'|null)
  * @param {Object} planConfig - Plan configuration
  * @param {Object} pathsConfig - Paths configuration
- * @returns {string} Reports path
+ * @param {string|null} baseDir - Optional base directory for absolute path resolution
+ * @returns {string} Reports path (absolute if baseDir provided, relative otherwise)
  */
-function getReportsPath(planPath, resolvedBy, planConfig, pathsConfig) {
+function getReportsPath(planPath, resolvedBy, planConfig, pathsConfig, baseDir = null) {
   const reportsDir = normalizePath(planConfig?.reportsDir) || 'reports';
   const plansDir = normalizePath(pathsConfig?.plans) || 'plans';
 
+  let reportPath;
   // Only use plan-specific reports path if explicitly active (session state)
-  if (planPath && resolvedBy === 'session') {
-    const normalizedPlanPath = normalizePath(planPath) || planPath;
-    return `${normalizedPlanPath}/${reportsDir}/`;
+  // Issue #327: Validate normalized path to prevent whitespace-only paths creating invalid directories
+  const normalizedPlanPath = planPath && resolvedBy === 'session' ? normalizePath(planPath) : null;
+  if (normalizedPlanPath) {
+    reportPath = `${normalizedPlanPath}/${reportsDir}`;
+  } else {
+    // Default path for no plan or suggested (branch-matched) plans
+    reportPath = `${plansDir}/${reportsDir}`;
+  }
+
+  // Return absolute path if baseDir provided
+  if (baseDir) {
+    return path.join(baseDir, reportPath);
   }
-  // Default path for no plan or suggested (branch-matched) plans
-  return `${plansDir}/${reportsDir}/`;
+  return reportPath + '/';
 }
 
 /**
@@ -668,10 +750,50 @@ function resolveNamingPattern(planConfig, gitBranch) {
 
 /**
  * Get current git branch (safe execution)
+ * @param {string|null} cwd - Working directory to run git command from (optional)
  * @returns {string|null} Current branch name or null
  */
-function getGitBranch() {
-  return execSafe('git branch --show-current');
+function getGitBranch(cwd = null) {
+  return execSafe('git branch --show-current', { cwd: cwd || undefined });
+}
+
+/**
+ * Get git repository root directory
+ * @param {string|null} cwd - Working directory to run git command from (optional)
+ * @returns {string|null} Git root absolute path or null if not in git repo
+ */
+function getGitRoot(cwd = null) {
+  return execSafe('git rev-parse --show-toplevel', { cwd: cwd || undefined });
+}
+
+/**
+ * Extract task list ID from plan resolution for Claude Code Tasks coordination
+ * Only returns ID for session-resolved plans (explicitly active, not branch-suggested)
+ *
+ * Cross-platform: path.basename() handles both Unix/Windows separators
+ *
+ * @param {{ path: string|null, resolvedBy: 'session'|'branch'|null }} resolved - Plan resolution result
+ * @returns {string|null} Task list ID (plan directory name) or null
+ */
+function extractTaskListId(resolved) {
+  if (!resolved || resolved.resolvedBy !== 'session' || !resolved.path) {
+    return null;
+  }
+  return path.basename(resolved.path);
+}
+
+/**
+ * Check if a hook is enabled in config
+ * Returns true if hook is not defined (default enabled)
+ *
+ * @param {string} hookName - Hook name (script basename without .cjs)
+ * @returns {boolean} Whether hook is enabled
+ */
+function isHookEnabled(hookName) {
+  const config = loadConfig({ includeProject: false, includeAssertions: false, includeLocale: false });
+  const hooks = config.hooks || {};
+  // Return true if undefined (default enabled), otherwise return the boolean value
+  return hooks[hookName] !== false;
 }
 
 module.exports = {
@@ -702,5 +824,8 @@ module.exports = {
   formatDate,
   validateNamingPattern,
   resolveNamingPattern,
-  getGitBranch
+  getGitBranch,
+  getGitRoot,
+  extractTaskListId,
+  isHookEnabled
 };

package/templates/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/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 };