claude-code-pilot 3.2.0 → 3.3.1

package/src/hooks/ccp-context-monitor.js

@@ -26,6 +26,21 @@ const CRITICAL_THRESHOLD = 25; // remaining_percentage <= 25%
 const STALE_SECONDS = 60;      // ignore metrics older than 60s
 const DEBOUNCE_CALLS = 5;      // min tool uses between warnings
 
+// Cost-warning opt-out (backport of ECC b47dfa95, re-expressed for CCP).
+// Set CCP_CONTEXT_MONITOR_COST_WARNINGS=0 (or false/off/no/disabled) to suppress
+// cost-warning emission. Default ON. CCP's monitor currently emits context
+// warnings only; this gate future-proofs any cost-warning emission point.
+function isEnabledEnv(value, defaultValue = true) {
+  if (value == null || String(value).trim() === '') return defaultValue;
+  const n = String(value).trim().toLowerCase();
+  if (['0', 'false', 'no', 'off', 'disabled'].includes(n)) return false;
+  if (['1', 'true', 'yes', 'on', 'enabled'].includes(n)) return true;
+  return defaultValue;
+}
+function costWarningsEnabled(env = process.env) {
+  return isEnabledEnv(env.CCP_CONTEXT_MONITOR_COST_WARNINGS, true); // CCP-branded rename of the upstream cost-warning opt-out (b47dfa95)
+}
+
 let input = '';
 // Timeout guard: if stdin doesn't close within 3s (e.g. pipe issues on
 // Windows/Git Bash), exit silently instead of hanging until Claude Code
@@ -134,6 +149,14 @@ process.stdin.on('end', () => {
     };
 
     process.stdout.write(JSON.stringify(output));
+
+    // --- Cost-warning emission point (gated by CCP_CONTEXT_MONITOR_COST_WARNINGS) ---
+    // CCP's statusline bridge does not currently surface per-session cost data, so
+    // this branch is a no-op today. When metrics.cost_* becomes available, emit the
+    // cost advisory HERE, guarded by the opt-out so users can suppress it.
+    if (costWarningsEnabled() && metrics && metrics.cost_warning) {
+      // (future) emit cost advisory via hookSpecificOutput.additionalContext
+    }
   } catch (e) {
     // Silent fail -- never block tool execution
     process.exit(0);

package/src/hooks/ccp-doc-file-warning.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// Doc File Warning - PreToolUse (Write) hook
+// Warns-only advisory: never blocks the Write, ALWAYS exits 0.
+//
+// Uses a denylist approach: only warn on known ad-hoc documentation
+// filenames (NOTES, TODO, SCRATCH, etc.) written outside structured
+// directories. This avoids false positives for legitimate
+// markdown-heavy workflows (specs, ADRs, command definitions, skill
+// files, etc.).
+//
+// How it works:
+// 1. Reads the PreToolUse JSON payload from stdin (tool_input.file_path).
+// 2. If the basename matches a known ad-hoc doc filename AND the path is
+//    NOT inside a structured directory, emits an advisory to stderr.
+// 3. Exits 0 unconditionally (advisory only, never blocks the write).
+//
+// On empty or unparseable stdin it exits 0 silently. Stdlib-only (path).
+
+'use strict';
+
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+
+// Known ad-hoc filenames that signal impulse/scratch docs (case-sensitive, uppercase).
+const ADHOC_FILENAMES = /^(NOTES|TODO|SCRATCH|TEMP|DRAFT|BRAINSTORM|SPIKE|DEBUG|WIP)\.(md|txt)$/;
+
+// Structured directories where even ad-hoc names are intentional.
+const STRUCTURED_DIRS = /(^|\/)(docs|\.claude|\.github|commands|skills|benchmarks|templates|\.history|memory)\//;
+
+function isSuspiciousDocPath(filePath) {
+  const normalized = String(filePath).replace(/\\/g, '/');
+  const basename = path.basename(normalized);
+
+  // Only inspect .md and .txt files (case-sensitive, consistent with ADHOC_FILENAMES).
+  if (!/\.(md|txt)$/.test(basename)) return false;
+
+  // Only flag known ad-hoc filenames.
+  if (!ADHOC_FILENAMES.test(basename)) return false;
+
+  // Allow ad-hoc names inside structured directories (intentional usage).
+  if (STRUCTURED_DIRS.test(normalized)) return false;
+
+  return true;
+}
+
+// Pure decision function. Returns an advisory string (for stderr) or null.
+// Exported for testing; the CLI below drives it from stdin.
+function matchesDenylist(rawInput) {
+  let input;
+  try {
+    input = typeof rawInput === 'string'
+      ? (rawInput.trim() ? JSON.parse(rawInput) : {})
+      : (rawInput || {});
+  } catch (_e) {
+    return null;
+  }
+
+  const filePath = String((input && input.tool_input && input.tool_input.file_path) || '');
+  if (!filePath || !isSuspiciousDocPath(filePath)) return null;
+
+  return (
+    '[Hook] WARNING: Ad-hoc documentation filename detected\n' +
+    '[Hook] File: ' + filePath + '\n' +
+    '[Hook] Consider a structured path (e.g. docs/, .claude/, skills/, .github/, benchmarks/, templates/)'
+  );
+}
+
+module.exports = { matchesDenylist, isSuspiciousDocPath };
+
+if (require.main === module) {
+  let data = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (data.length < MAX_STDIN) {
+      data += chunk.substring(0, MAX_STDIN - data.length);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    const advisory = matchesDenylist(data);
+    if (advisory) {
+      process.stderr.write(advisory + '\n');
+    }
+    // Pass the payload through unchanged; warns-only, never blocks.
+    process.stdout.write(data);
+    process.exit(0);
+  });
+
+  // Empty/closed stdin: exit 0 silently.
+  process.stdin.on('error', () => process.exit(0));
+}

package/src/hooks/ccp-pre-bash-dispatcher.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+'use strict';
+
+const { runPreBash } = require('./ccp-bash-hook-dispatcher');
+
+let raw = '';
+const MAX_STDIN = 1024 * 1024;
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  if (raw.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - raw.length;
+    raw += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  const result = runPreBash(raw);
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  process.stdout.write(result.output);
+  process.exitCode = result.exitCode;
+});