thanh-kit 2.5.0 → 2.5.2

package/templates/hooks/post-edit-simplify-reminder.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook: Tracks file modifications and reminds to run code-simplifier
+ *
+ * This hook fires after Edit/Write/MultiEdit operations and:
+ * 1. Tracks modified files in the session
+ * 2. After significant edits, injects a reminder to run code-simplifier
+ *
+ * Auto-trigger behavior:
+ * - Tracks edit count per session
+ * - After 5+ file edits, reminds about code-simplifier
+ * - Resets counter when simplifier is mentioned in conversation
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const { isHookEnabled } = require('./lib/ck-config-utils.cjs');
+  const { invalidateCache } = require('./lib/git-info-cache.cjs');
+
+  // Early exit if hook disabled in config
+  if (!isHookEnabled('post-edit-simplify-reminder')) {
+    process.exit(0);
+  }
+
+// Session tracking file
+const SESSION_TRACK_FILE = path.join(os.tmpdir(), 'ck-simplify-session.json');
+const EDIT_THRESHOLD = 5; // Remind after this many edits
+
+/**
+ * Load or initialize session tracking data
+ */
+function loadSessionData() {
+  try {
+    if (fs.existsSync(SESSION_TRACK_FILE)) {
+      const data = JSON.parse(fs.readFileSync(SESSION_TRACK_FILE, 'utf8'));
+      // Reset if session is older than 2 hours
+      if (Date.now() - data.startTime > 2 * 60 * 60 * 1000) {
+        return initSessionData();
+      }
+      return data;
+    }
+  } catch (e) {
+    // Ignore errors, reinitialize
+  }
+  return initSessionData();
+}
+
+/**
+ * Initialize fresh session data
+ */
+function initSessionData() {
+  return {
+    startTime: Date.now(),
+    editCount: 0,
+    modifiedFiles: [],
+    lastReminder: 0,
+    simplifierRun: false
+  };
+}
+
+/**
+ * Save session tracking data
+ */
+function saveSessionData(data) {
+  try {
+    fs.writeFileSync(SESSION_TRACK_FILE, JSON.stringify(data, null, 2));
+  } catch (e) {
+    // Ignore write errors
+  }
+}
+
+/**
+ * Main hook logic
+ */
+function main() {
+  try {
+    // Read hook input from stdin
+    let input = '';
+    const stdin = fs.readFileSync(0, 'utf8');
+    if (stdin) {
+      input = stdin;
+    }
+
+    const hookData = JSON.parse(input || '{}');
+    const toolName = hookData.tool_name || '';
+    const toolInput = hookData.tool_input || {};
+
+    // Only track edit operations
+    const editTools = ['Edit', 'Write', 'MultiEdit'];
+    if (!editTools.includes(toolName)) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    // Invalidate git cache so statusline shows fresh state after file changes
+    // Use hookData.cwd (not process.cwd()) to handle subagent CWD mismatch
+    invalidateCache(hookData.cwd || process.cwd());
+
+    // Load session data
+    const session = loadSessionData();
+
+    // Track the edit
+    session.editCount++;
+    const filePath = toolInput.file_path || toolInput.path || '';
+    if (filePath && !session.modifiedFiles.includes(filePath)) {
+      session.modifiedFiles.push(filePath);
+    }
+
+    // Check if we should remind about code-simplifier
+    const shouldRemind =
+      session.editCount >= EDIT_THRESHOLD &&
+      !session.simplifierRun &&
+      (Date.now() - session.lastReminder > 10 * 60 * 1000); // Don't remind more than every 10 min
+
+    let additionalContext = '';
+    if (shouldRemind) {
+      session.lastReminder = Date.now();
+      additionalContext = `\n\n[Code Simplification Reminder] You have modified ${session.modifiedFiles.length} files in this session. Consider using the \`code-simplifier\` agent to refine recent changes before proceeding to code review. This is a MANDATORY step in the workflow.`;
+    }
+
+    // Save updated session data
+    saveSessionData(session);
+
+    // Output hook result
+    const result = {
+      continue: true
+    };
+
+    if (additionalContext) {
+      result.additionalContext = additionalContext;
+    }
+
+    console.log(JSON.stringify(result));
+
+  } catch (e) {
+    // On error, allow the operation to continue
+    console.log(JSON.stringify({ continue: true }));
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging (zero deps — only Node builtins)
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/templates/hooks/privacy-block.cjs

@@ -10,171 +10,55 @@
  * 2. LLM asks user for permission
  * 3. User approves
  * 4. LLM retries: Read "APPROVED:.env" → ALLOWED
+ *
+ * Core logic extracted to lib/privacy-checker.cjs for OpenCode plugin reuse.
  */
 
-const path = require('path');
-const fs = require('fs');
-
-const APPROVED_PREFIX = 'APPROVED:';
-
-// Safe file patterns - exempt from privacy checks (documentation/template files)
-const SAFE_PATTERNS = [
-  /\.example$/i,   // .env.example, config.example
-  /\.sample$/i,    // .env.sample
-  /\.template$/i,  // .env.template
-];
-
-// Privacy-sensitive patterns
-const PRIVACY_PATTERNS = [
-  /^\.env$/,              // .env
-  /^\.env\./,             // .env.local, .env.production, etc.
-  /\.env$/,               // path/to/.env
-  /\/\.env\./,            // path/to/.env.local
-  /credentials/i,         // credentials.json, etc.
-  /secrets?\.ya?ml$/i,    // secrets.yaml, secret.yml
-  /\.pem$/,               // Private keys
-  /\.key$/,               // Private keys
-  /id_rsa/,               // SSH keys
-  /id_ed25519/,           // SSH keys
-];
-
-/**
- * Load .ck.json config to check if privacy block is disabled
- * @returns {boolean} true if privacy block should be skipped
- */
-function isPrivacyBlockDisabled() {
-  try {
-    const configPath = path.join(process.cwd(), '.claude', '.ck.json');
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    return config.privacyBlock === false;
-  } catch {
-    return false; // Default to enabled on error (file not found or invalid JSON)
-  }
-}
-
-/**
- * Check if path is a safe file (example/sample/template)
- * @param {string} testPath - Path to check
- * @returns {boolean} true if file matches safe patterns
- */
-function isSafeFile(testPath) {
-  if (!testPath) return false;
-  const basename = path.basename(testPath);
-  return SAFE_PATTERNS.some(p => p.test(basename));
-}
-
-/**
- * Check if path has APPROVED: prefix
- * @param {string} testPath - Path to check
- * @returns {boolean} true if path starts with APPROVED:
- */
-function hasApprovalPrefix(testPath) {
-  return testPath && testPath.startsWith(APPROVED_PREFIX);
-}
-
-/**
- * Strip APPROVED: prefix from path, warn on suspicious paths
- * @param {string} testPath - Path to process
- * @returns {string} Path without APPROVED: prefix
- */
-function stripApprovalPrefix(testPath) {
-  if (hasApprovalPrefix(testPath)) {
-    const stripped = testPath.slice(APPROVED_PREFIX.length);
-
-    // Warn on suspicious paths (path traversal or absolute)
-    if (stripped.includes('..') || path.isAbsolute(stripped)) {
-      console.error('\x1b[33mWARN:\x1b[0m Approved path is outside project:', stripped);
-    }
-
-    return stripped;
-  }
-  return testPath;
-}
-
-/**
- * Check if path matches privacy patterns
- * @param {string} testPath - Path to check
- * @returns {boolean} true if path matches privacy-sensitive patterns
- */
-function isPrivacySensitive(testPath) {
-  if (!testPath) return false;
-
-  // Strip prefix for pattern matching
-  const cleanPath = stripApprovalPrefix(testPath);
-  let normalized = cleanPath.replace(/\\/g, '/');
-
-  // Decode URI components to catch obfuscated paths (%2e = '.')
+(async () => {
   try {
-    normalized = decodeURIComponent(normalized);
-  } catch (e) {
-    // Invalid encoding, use as-is
-  }
-
-  // Check safe patterns first - exempt example/sample/template files
-  if (isSafeFile(normalized)) {
-    return false;
-  }
-
-  const basename = path.basename(normalized);
-
-  for (const pattern of PRIVACY_PATTERNS) {
-    if (pattern.test(basename) || pattern.test(normalized)) {
-      return true;
+    const path = require('path');
+
+    // Import shared privacy checking logic
+    const {
+      checkPrivacy,
+      isSafeFile,
+      isPrivacyBlockDisabled,
+      isPrivacySensitive,
+      hasApprovalPrefix,
+      stripApprovalPrefix,
+      extractPaths,
+      isSuspiciousPath
+    } = require('./lib/privacy-checker.cjs');
+    const { isHookEnabled } = require('./lib/ck-config-utils.cjs');
+
+    // Early exit if hook disabled in config
+    if (!isHookEnabled('privacy-block')) {
+      process.exit(0);
     }
-  }
-  return false;
-}
 
 /**
- * Extract paths from tool input
- * @param {Object} toolInput - Tool input object with file_path, path, pattern, or command
- * @returns {Array<{value: string, field: string}>} Array of extracted paths with field names
- */
-function extractPaths(toolInput) {
-  const paths = [];
-  if (!toolInput) return paths;
-
-  if (toolInput.file_path) paths.push({ value: toolInput.file_path, field: 'file_path' });
-  if (toolInput.path) paths.push({ value: toolInput.path, field: 'path' });
-  if (toolInput.pattern) paths.push({ value: toolInput.pattern, field: 'pattern' });
-
-  // Check bash commands for file paths
-  if (toolInput.command) {
-    // Look for APPROVED:.env or .env patterns
-    const approvedMatch = toolInput.command.match(/APPROVED:[^\s]+/g) || [];
-    approvedMatch.forEach(p => paths.push({ value: p, field: 'command' }));
-
-    // Only look for .env if no APPROVED: version found
-    if (approvedMatch.length === 0) {
-      const envMatch = toolInput.command.match(/\.env[^\s]*/g) || [];
-      envMatch.forEach(p => paths.push({ value: p, field: 'command' }));
-
-      // Also check bash variable assignments (FILE=.env, ENV_FILE=.env.local)
-      const varAssignments = toolInput.command.match(/\w+=[^\s]*\.env[^\s]*/g) || [];
-      varAssignments.forEach(a => {
-        const value = a.split('=')[1];
-        if (value) paths.push({ value, field: 'command' });
-      });
-
-      // Check command substitution containing sensitive patterns - extract .env from inside
-      const cmdSubst = toolInput.command.match(/\$\([^)]*?(\.env[^\s)]*)[^)]*\)/g) || [];
-      for (const subst of cmdSubst) {
-        const inner = subst.match(/\.env[^\s)]*/);
-        if (inner) paths.push({ value: inner[0], field: 'command' });
-      }
-    }
-  }
-
-  return paths.filter(p => p.value);
-}
-
-/**
- * Format block message with approval instructions
+ * Format block message with approval instructions and JSON marker for AskUserQuestion
  * @param {string} filePath - Blocked file path
- * @returns {string} Formatted block message
+ * @returns {string} Formatted block message with JSON marker
  */
 function formatBlockMessage(filePath) {
   const basename = path.basename(filePath);
+
+  // JSON marker for LLM to parse and use AskUserQuestion tool
+  const promptData = {
+    type: 'PRIVACY_PROMPT',
+    file: filePath,
+    basename: basename,
+    question: {
+      header: 'File Access',
+      text: `I need to read "${basename}" which may contain sensitive data (API keys, passwords, tokens). Do you approve?`,
+      options: [
+        { label: 'Yes, approve access', description: `Allow reading ${basename} this time` },
+        { label: 'No, skip this file', description: 'Continue without accessing this file' }
+      ]
+    }
+  };
+
   return `
 \x1b[36mNOTE:\x1b[0m This is not an error - this block protects sensitive data.
 
@@ -184,11 +68,13 @@ function formatBlockMessage(filePath) {
 
   This file may contain secrets (API keys, passwords, tokens).
 
-  \x1b[34mAction required:\x1b[0m
-  Ask user: "I need to read ${basename} which may contain sensitive data. Approve?"
+\x1b[90m@@PRIVACY_PROMPT_START@@\x1b[0m
+${JSON.stringify(promptData, null, 2)}
+\x1b[90m@@PRIVACY_PROMPT_END@@\x1b[0m
 
-  \x1b[32mIf YES:\x1b[0m Retry with prefix: APPROVED:${filePath}
-  \x1b[31mIf NO:\x1b[0m  Do NOT retry. Continue without this file.
+  \x1b[34mClaude:\x1b[0m Use AskUserQuestion tool with the JSON above, then:
+  \x1b[32mIf "Yes":\x1b[0m Use bash to read: cat "${filePath}"
+  \x1b[31mIf "No":\x1b[0m  Continue without this file.
 `;
 }
 
@@ -203,11 +89,6 @@ function formatApprovalNotice(filePath) {
 
 // Main
 async function main() {
-  // Check if privacy block is disabled via .ck.json
-  if (isPrivacyBlockDisabled()) {
-    process.exit(0); // Disabled, allow all
-  }
-
   let input = '';
   for await (const chunk of process.stdin) {
     input += chunk;
@@ -220,38 +101,66 @@ async function main() {
     process.exit(0); // Invalid JSON, allow
   }
 
-  const { tool_input: toolInput } = hookData;
-  const paths = extractPaths(toolInput);
+  const { tool_input: toolInput, tool_name: toolName } = hookData;
 
-  // Check each path
-  for (const { value: testPath } of paths) {
-    if (!isPrivacySensitive(testPath)) continue;
+  // Use shared privacy checker
+  const result = checkPrivacy({
+    toolName,
+    toolInput,
+    options: { allowBash: true }
+  });
 
-    // Check for approval prefix
-    if (hasApprovalPrefix(testPath)) {
-      // User approved - allow with notice
-      console.error(formatApprovalNotice(testPath));
-      continue; // Check other paths
+  // Handle results
+  if (result.approved) {
+    // User approved - allow with notice
+    if (result.suspicious) {
+      console.error('\x1b[33mWARN:\x1b[0m Approved path is outside project:', result.filePath);
     }
+    console.error(formatApprovalNotice(result.filePath));
+    process.exit(0);
+  }
 
+  if (result.isBash) {
+    // Bash: warn but don't block - allows "Yes → bash cat" flow
+    console.error(`\x1b[33mWARN:\x1b[0m ${result.reason}`);
+    process.exit(0);
+  }
+
+  if (result.blocked) {
     // No approval - block
-    console.error(formatBlockMessage(testPath));
-    process.exit(2); // Block
+    console.error(formatBlockMessage(result.filePath));
+    process.exit(2);
   }
 
   process.exit(0); // Allow
 }
 
-main().catch(() => process.exit(0));
+    // Run main only when executed directly (not when required for testing)
+    if (require.main === module) {
+      main().catch(() => process.exit(0));
+    }
 
-// Export functions for unit testing
-if (typeof module !== 'undefined') {
-  module.exports = {
-    isSafeFile,
-    isPrivacyBlockDisabled,
-    isPrivacySensitive,
-    hasApprovalPrefix,
-    stripApprovalPrefix,
-    extractPaths,
-  };
-}
+    // Export functions for unit testing
+    if (typeof module !== 'undefined') {
+      module.exports = {
+        isSafeFile,
+        isPrivacyBlockDisabled,
+        isPrivacySensitive,
+        hasApprovalPrefix,
+        stripApprovalPrefix,
+        extractPaths,
+      };
+    }
+  } catch (e) {
+    // Minimal crash logging (zero deps — only Node builtins)
+    try {
+      const fs = require('fs');
+      const p = require('path');
+      const logDir = p.join(__dirname, '.logs');
+      if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+      fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+        JSON.stringify({ ts: new Date().toISOString(), hook: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+    } catch (_) {}
+    process.exit(0); // fail-open
+  }
+})();

package/templates/hooks/scout-block/broad-pattern-detector.cjs

@@ -24,16 +24,14 @@ const BROAD_PATTERN_REGEXES = [
   /^\*\*\/\*$/,
   // **/. - all dotfiles everywhere
   /^\*\*\/\.\*$/,
-  // **/*.ext - all files with extension (catches .ts, .py, .java, etc.)
-  /^\*\*\/\*\.\w+$/,
-  // **/*.{ext,ext2} - all files with multiple extensions
-  /^\*\*\/\*\.\{[^}]+\}$/,
-  // **/name.ext - all files with specific name anywhere
-  /^\*\*\/[\w-]+\.\w+$/,
   // *.ext at root (matches all in root, but combined with deep search)
   /^\*\.\w+$/,
   // *.{ext,ext2} at root
   /^\*\.\{[^}]+\}$/,
+  // **/*.ext - all files of type everywhere (e.g., **/*.ts, **/*.js)
+  /^\*\*\/\*\.\w+$/,
+  // **/*.{ext,ext2} - all files of multiple types everywhere
+  /^\*\*\/\*\.\{[^}]+\}$/,
 ];
 
 // Common source directories that indicate a more specific search

package/templates/hooks/scout-block/path-extractor.cjs

@@ -6,6 +6,26 @@
  * to find all path-like arguments.
  */
 
+// Flags that indicate the following value should NOT be checked as a path
+// These are "exclude" semantics - the user is explicitly skipping these paths
+const EXCLUDE_FLAGS = [
+  '--exclude', '--ignore', '--skip', '--prune',
+  '-x',           // tar exclude shorthand
+  '-path',        // find -path (used with -prune)
+  '--exclude-dir' // grep --exclude-dir
+];
+
+// Filesystem commands where bare directory names (build, dist, etc.)
+// should be extracted as paths. For non-fs commands (grep, echo, sed),
+// only tokens that look like actual paths (contain / or extension) are extracted.
+const FILESYSTEM_COMMANDS = [
+  'cd', 'ls', 'cat', 'head', 'tail', 'less', 'more',
+  'rm', 'cp', 'mv', 'find', 'touch', 'mkdir', 'rmdir',
+  'stat', 'file', 'du', 'tree', 'chmod', 'chown', 'ln',
+  'readlink', 'realpath', 'wc', 'tee', 'tar', 'zip', 'unzip',
+  'open', 'code', 'vim', 'nano', 'bat', 'rsync', 'scp', 'diff'
+];
+
 /**
  * Extract all paths from a tool_input object
  * Handles: file_path, path, pattern params and command strings
@@ -39,8 +59,12 @@ function extractFromToolInput(toolInput) {
 }
 
 /**
- * Extract path-like segments from a Bash command string
- * Handles quoted paths and filters out non-path tokens
+ * Extract path-like segments from a Bash command string.
+ *
+ * Uses pipe-segment-aware command context: for filesystem commands (cd, cat, ls, rm, etc.)
+ * bare blocked directory names are extracted with priority. For non-filesystem commands
+ * (grep, echo, sed, etc.) only tokens that structurally look like paths are extracted,
+ * preventing false positives on search terms and string arguments.
  *
  * @param {string} command - The command string
  * @returns {string[]} Array of extracted paths
@@ -56,8 +80,13 @@ function extractFromCommand(command) {
   const quotedPattern = /["']([^"']+)["']/g;
   let match;
   while ((match = quotedPattern.exec(command)) !== null) {
-    if (looksLikePath(match[1])) {
-      paths.push(normalizeExtractedPath(match[1]));
+    const content = match[1];
+
+    // Skip sed/awk regex expressions (s/pattern/replacement/flags)
+    if (/^s[\/|@#,]/.test(content)) continue;
+
+    if (looksLikePath(content)) {
+      paths.push(normalizeExtractedPath(content));
     }
   }
 
@@ -67,14 +96,72 @@ function extractFromCommand(command) {
   // Split on whitespace and extract path-like tokens
   const tokens = withoutQuotes.split(/\s+/).filter(Boolean);
 
+  // Track command context per pipe segment
+  let commandName = null;
+  let isFsCommand = false;
+  let skipNextToken = false;
+  let heredocDelimiter = null;
+  let nextIsHeredocDelimiter = false;
+
   for (const token of tokens) {
+    // Heredoc delimiter capture (after << or <<-)
+    if (nextIsHeredocDelimiter) {
+      heredocDelimiter = token.replace(/^['"]/, '').replace(/['"]$/, '');
+      nextIsHeredocDelimiter = false;
+      continue;
+    }
+
+    // Skip heredoc body content until closing delimiter
+    if (heredocDelimiter) {
+      if (token === heredocDelimiter) {
+        heredocDelimiter = null;
+      }
+      continue;
+    }
+
+    // Detect heredoc start: <<EOF, <<'EOF', <<"EOF", <<-EOF
+    if (token.startsWith('<<') && token.length > 2) {
+      heredocDelimiter = token.replace(/^<<-?['"]?/, '').replace(/['"]?$/, '');
+      continue;
+    }
+    if (token === '<<' || token === '<<-') {
+      nextIsHeredocDelimiter = true;
+      continue;
+    }
+
+    // Skip value after exclude flags (--exclude node_modules format)
+    if (skipNextToken) {
+      skipNextToken = false;
+      continue;
+    }
+
+    // Reset command context at command/pipe boundaries
+    if (token === '&&' || token === ';' || token.startsWith('|')) {
+      commandName = null;
+      isFsCommand = false;
+      continue;
+    }
+
     // Skip flags and shell operators
-    if (isSkippableToken(token)) continue;
+    if (isSkippableToken(token)) {
+      if (EXCLUDE_FLAGS.includes(token)) {
+        skipNextToken = true;
+      }
+      continue;
+    }
 
-    // Priority check: if token IS a blocked directory name exactly, include it
-    // This handles cases like "cd build" where "build" is both a command word
-    // and a blocked directory name
-    if (isBlockedDirName(token)) {
+    // Determine the command for this pipe segment (first non-flag token)
+    if (commandName === null) {
+      commandName = token.toLowerCase();
+      isFsCommand = FILESYSTEM_COMMANDS.includes(commandName);
+      // Skip the command word itself
+      if (isCommandKeyword(token) || isFsCommand) continue;
+      // Non-keyword command (e.g., ./script.sh) — fall through to path check
+    }
+
+    // For filesystem commands, extract blocked dir names with priority.
+    // "cd build", "ls dist", "cat node_modules/..." — "build"/"dist" are paths here.
+    if (isFsCommand && isBlockedDirName(token)) {
       paths.push(normalizeExtractedPath(token));
       continue;
     }
@@ -128,9 +215,6 @@ function looksLikePath(str) {
   // Has file extension (likely a file)
   if (/\.\w{1,6}$/.test(str)) return true;
 
-  // Contains common blocked directory names
-  if (/node_modules|__pycache__|\.git|dist|build/.test(str)) return true;
-
   // Looks like a directory path
   if (/^[a-zA-Z0-9_-]+\//.test(str)) return true;
 
@@ -215,6 +299,9 @@ function normalizeExtractedPath(path) {
     normalized = normalized.slice(1, -1);
   }
 
+  // Strip shell metacharacters from edges (backticks, parens, braces)
+  normalized = normalized.replace(/^[`({\[]+/, '').replace(/[`)};\]]+$/, '');
+
   // Normalize path separators to forward slash
   normalized = normalized.replace(/\\/g, '/');
 
@@ -234,5 +321,7 @@ module.exports = {
   isCommandKeyword,
   isBlockedDirName,
   normalizeExtractedPath,
-  BLOCKED_DIR_NAMES
+  BLOCKED_DIR_NAMES,
+  EXCLUDE_FLAGS,
+  FILESYSTEM_COMMANDS
 };