cc4pm 1.8.0

package/scripts/ecc.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { listAvailableLanguages } = require('./lib/install-executor');
+
+const COMMANDS = {
+  install: {
+    script: 'install-apply.js',
+    description: 'Install cc4pm content into a supported target',
+  },
+  plan: {
+    script: 'install-plan.js',
+    description: 'Inspect selective-install manifests and resolved plans',
+  },
+  'install-plan': {
+    script: 'install-plan.js',
+    description: 'Alias for plan',
+  },
+  'list-installed': {
+    script: 'list-installed.js',
+    description: 'Inspect install-state files for the current context',
+  },
+  doctor: {
+    script: 'doctor.js',
+    description: 'Diagnose missing or drifted ECC-managed files',
+  },
+  repair: {
+    script: 'repair.js',
+    description: 'Restore drifted or missing ECC-managed files',
+  },
+  'session-inspect': {
+    script: 'session-inspect.js',
+    description: 'Emit canonical cc4pm session snapshots from dmux or Claude history targets',
+  },
+  uninstall: {
+    script: 'uninstall.js',
+    description: 'Remove ECC-managed files recorded in install-state',
+  },
+};
+
+const PRIMARY_COMMANDS = [
+  'install',
+  'plan',
+  'list-installed',
+  'doctor',
+  'repair',
+  'session-inspect',
+  'uninstall',
+];
+
+function showHelp(exitCode = 0) {
+  console.log(`
+cc4pm selective-install CLI
+
+Usage:
+  ecc <command> [args...]
+  ecc [install args...]
+
+Commands:
+${PRIMARY_COMMANDS.map(command => `  ${command.padEnd(15)} ${COMMANDS[command].description}`).join('\n')}
+
+Compatibility:
+  ecc-install        Legacy install entrypoint retained for existing flows
+  ecc [args...]      Without a command, args are routed to "install"
+  ecc help <command> Show help for a specific command
+
+Examples:
+  ecc typescript
+  ecc install --profile developer --target claude
+  ecc plan --profile core --target cursor
+  ecc list-installed --json
+  ecc doctor --target cursor
+  ecc repair --dry-run
+  ecc session-inspect claude:latest
+  ecc uninstall --target antigravity --dry-run
+`);
+
+  process.exit(exitCode);
+}
+
+function resolveCommand(argv) {
+  const args = argv.slice(2);
+
+  if (args.length === 0) {
+    return { mode: 'help' };
+  }
+
+  const [firstArg, ...restArgs] = args;
+
+  if (firstArg === '--help' || firstArg === '-h') {
+    return { mode: 'help' };
+  }
+
+  if (firstArg === 'help') {
+    return {
+      mode: 'help-command',
+      command: restArgs[0] || null,
+    };
+  }
+
+  if (COMMANDS[firstArg]) {
+    return {
+      mode: 'command',
+      command: firstArg,
+      args: restArgs,
+    };
+  }
+
+  const knownLegacyLanguages = listAvailableLanguages();
+  const shouldTreatAsImplicitInstall = (
+    firstArg.startsWith('-')
+    || knownLegacyLanguages.includes(firstArg)
+  );
+
+  if (!shouldTreatAsImplicitInstall) {
+    throw new Error(`Unknown command: ${firstArg}`);
+  }
+
+  return {
+    mode: 'command',
+    command: 'install',
+    args,
+  };
+}
+
+function runCommand(commandName, args) {
+  const command = COMMANDS[commandName];
+  if (!command) {
+    throw new Error(`Unknown command: ${commandName}`);
+  }
+
+  const result = spawnSync(
+    process.execPath,
+    [path.join(__dirname, command.script), ...args],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+      encoding: 'utf8',
+    }
+  );
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+
+  if (typeof result.status === 'number') {
+    return result.status;
+  }
+
+  if (result.signal) {
+    throw new Error(`Command "${commandName}" terminated by signal ${result.signal}`);
+  }
+
+  return 1;
+}
+
+function main() {
+  try {
+    const resolution = resolveCommand(process.argv);
+
+    if (resolution.mode === 'help') {
+      showHelp(0);
+    }
+
+    if (resolution.mode === 'help-command') {
+      if (!resolution.command) {
+        showHelp(0);
+      }
+
+      if (!COMMANDS[resolution.command]) {
+        throw new Error(`Unknown command: ${resolution.command}`);
+      }
+
+      process.exitCode = runCommand(resolution.command, ['--help']);
+      return;
+    }
+
+    process.exitCode = runCommand(resolution.command, resolution.args);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/hooks/auto-tmux-dev.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Auto-Tmux Dev Hook - Start dev servers in tmux/cmd automatically
+ *
+ * macOS/Linux: Runs dev server in a named tmux session (non-blocking).
+ *              Falls back to original command if tmux is not installed.
+ * Windows: Opens dev server in a new cmd window (non-blocking).
+ *
+ * Runs before Bash tool use. If command is a dev server (npm run dev, pnpm dev, yarn dev, bun run dev),
+ * transforms it to run in a detached session.
+ *
+ * Benefits:
+ * - Dev server runs detached (doesn't block Claude Code)
+ * - Session persists (can run `tmux capture-pane -t <session> -p` to see logs on Unix)
+ * - Session name matches project directory (allows multiple projects simultaneously)
+ *
+ * Session management (Unix):
+ * - Checks tmux availability before transforming
+ * - Kills any existing session with the same name (clean restart)
+ * - Creates new detached session
+ * - Reports session name and how to view logs
+ *
+ * Session management (Windows):
+ * - Opens new cmd window with descriptive title
+ * - Allows multiple dev servers to run simultaneously
+ */
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MAX_STDIN = 1024 * 1024; // 1MB limit
+let data = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  let input;
+  try {
+    input = JSON.parse(data);
+    const cmd = input.tool_input?.command || '';
+
+    // Detect dev server commands: npm run dev, pnpm dev, yarn dev, bun run dev
+    // Use word boundary (\b) to avoid matching partial commands
+    const devServerRegex = /(npm run dev\b|pnpm( run)? dev\b|yarn dev\b|bun run dev\b)/;
+
+    if (devServerRegex.test(cmd)) {
+      // Get session name from current directory basename, sanitize for shell safety
+      // e.g., /home/user/Portfolio → "Portfolio", /home/user/my-app-v2 → "my-app-v2"
+      const rawName = path.basename(process.cwd());
+      // Replace non-alphanumeric characters (except - and _) with underscore to prevent shell injection
+      const sessionName = rawName.replace(/[^a-zA-Z0-9_-]/g, '_') || 'dev';
+
+      if (process.platform === 'win32') {
+        // Windows: open in a new cmd window (non-blocking)
+        // Escape double quotes in cmd for cmd /k syntax
+        const escapedCmd = cmd.replace(/"/g, '""');
+        input.tool_input.command = `start "DevServer-${sessionName}" cmd /k "${escapedCmd}"`;
+      } else {
+        // Unix (macOS/Linux): Check tmux is available before transforming
+        const tmuxCheck = spawnSync('which', ['tmux'], { encoding: 'utf8' });
+        if (tmuxCheck.status === 0) {
+          // Escape single quotes for shell safety: 'text' -> 'text'\''text'
+          const escapedCmd = cmd.replace(/'/g, "'\\''");
+
+          // Build the transformed command:
+          // 1. Kill existing session (silent if doesn't exist)
+          // 2. Create new detached session with the dev command
+          // 3. Echo confirmation message with instructions for viewing logs
+          const transformedCmd = `SESSION="${sessionName}"; tmux kill-session -t "$SESSION" 2>/dev/null || true; tmux new-session -d -s "$SESSION" '${escapedCmd}' && echo "[Hook] Dev server started in tmux session '${sessionName}'. View logs: tmux capture-pane -t ${sessionName} -p -S -100"`;
+
+          input.tool_input.command = transformedCmd;
+        }
+        // else: tmux not found, pass through original command unchanged
+      }
+    }
+    process.stdout.write(JSON.stringify(input));
+  } catch {
+    // Invalid input — pass through original data unchanged
+    process.stdout.write(data);
+  }
+  process.exit(0);
+});

package/scripts/hooks/check-console-log.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+/**
+ * Stop Hook: Check for console.log statements in modified files
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs after each response and checks if any modified JavaScript/TypeScript
+ * files contain console.log statements. Provides warnings to help developers
+ * remember to remove debug statements before committing.
+ *
+ * Exclusions: test files, config files, and scripts/ directory (where
+ * console.log is often intentional).
+ */
+
+const fs = require('fs');
+const { isGitRepo, getGitModifiedFiles, readFile, log } = require('../lib/utils');
+
+// Files where console.log is expected and should not trigger warnings
+const EXCLUDED_PATTERNS = [
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/,
+  /\.config\.[jt]s$/,
+  /scripts\//,
+  /__tests__\//,
+  /__mocks__\//,
+];
+
+const MAX_STDIN = 1024 * 1024; // 1MB limit
+let data = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    if (!isGitRepo()) {
+      process.stdout.write(data);
+      process.exit(0);
+    }
+
+    const files = getGitModifiedFiles(['\\.tsx?$', '\\.jsx?$'])
+      .filter(f => fs.existsSync(f))
+      .filter(f => !EXCLUDED_PATTERNS.some(pattern => pattern.test(f)));
+
+    let hasConsole = false;
+
+    for (const file of files) {
+      const content = readFile(file);
+      if (content && content.includes('console.log')) {
+        log(`[Hook] WARNING: console.log found in ${file}`);
+        hasConsole = true;
+      }
+    }
+
+    if (hasConsole) {
+      log('[Hook] Remove console.log statements before committing');
+    }
+  } catch (err) {
+    log(`[Hook] check-console-log error: ${err.message}`);
+  }
+
+  // Always output the original data
+  process.stdout.write(data);
+  process.exit(0);
+});

package/scripts/hooks/check-hook-enabled.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+
+const { isHookEnabled } = require('../lib/hook-flags');
+
+const [, , hookId, profilesCsv] = process.argv;
+if (!hookId) {
+  process.stdout.write('yes');
+  process.exit(0);
+}
+
+process.stdout.write(isHookEnabled(hookId, { profiles: profilesCsv }) ? 'yes' : 'no');

package/scripts/hooks/cost-tracker.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Cost Tracker Hook
+ *
+ * Appends lightweight session usage metrics to ~/.claude/metrics/costs.jsonl.
+ */
+
+'use strict';
+
+const path = require('path');
+const {
+  ensureDir,
+  appendFile,
+  getClaudeDir,
+} = require('../lib/utils');
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+function toNumber(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function estimateCost(model, inputTokens, outputTokens) {
+  // Approximate per-1M-token blended rates. Conservative defaults.
+  const table = {
+    'haiku': { in: 0.8, out: 4.0 },
+    'sonnet': { in: 3.0, out: 15.0 },
+    'opus': { in: 15.0, out: 75.0 },
+  };
+
+  const normalized = String(model || '').toLowerCase();
+  let rates = table.sonnet;
+  if (normalized.includes('haiku')) rates = table.haiku;
+  if (normalized.includes('opus')) rates = table.opus;
+
+  const cost = (inputTokens / 1_000_000) * rates.in + (outputTokens / 1_000_000) * rates.out;
+  return Math.round(cost * 1e6) / 1e6;
+}
+
+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', () => {
+  try {
+    const input = raw.trim() ? JSON.parse(raw) : {};
+    const usage = input.usage || input.token_usage || {};
+    const inputTokens = toNumber(usage.input_tokens || usage.prompt_tokens || 0);
+    const outputTokens = toNumber(usage.output_tokens || usage.completion_tokens || 0);
+
+    const model = String(input.model || input._cursor?.model || process.env.CLAUDE_MODEL || 'unknown');
+    const sessionId = String(process.env.CLAUDE_SESSION_ID || 'default');
+
+    const metricsDir = path.join(getClaudeDir(), 'metrics');
+    ensureDir(metricsDir);
+
+    const row = {
+      timestamp: new Date().toISOString(),
+      session_id: sessionId,
+      model,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      estimated_cost_usd: estimateCost(model, inputTokens, outputTokens),
+    };
+
+    appendFile(path.join(metricsDir, 'costs.jsonl'), `${JSON.stringify(row)}\n`);
+  } catch {
+    // Keep hook non-blocking.
+  }
+
+  process.stdout.write(raw);
+});

package/scripts/hooks/doc-file-warning.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Doc file warning hook (PreToolUse - Write)
+ * Warns about non-standard documentation files.
+ * Exit code 0 always (warns only, never blocks).
+ */
+
+'use strict';
+
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+let data = '';
+
+function isAllowedDocPath(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  const basename = path.basename(filePath);
+
+  if (!/\.(md|txt)$/i.test(filePath)) return true;
+
+  if (/^(README|CLAUDE|AGENTS|CONTRIBUTING|CHANGELOG|LICENSE|SKILL|MEMORY|WORKLOG)\.md$/i.test(basename)) {
+    return true;
+  }
+
+  if (/\.claude\/(commands|plans|projects)\//.test(normalized)) {
+    return true;
+  }
+
+  if (/(^|\/)(docs|skills|\.history|memory)\//.test(normalized)) {
+    return true;
+  }
+
+  if (/\.plan\.md$/i.test(basename)) {
+    return true;
+  }
+
+  return false;
+}
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += c.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(data);
+    const filePath = String(input.tool_input?.file_path || '');
+
+    if (filePath && !isAllowedDocPath(filePath)) {
+      console.error('[Hook] WARNING: Non-standard documentation file detected');
+      console.error(`[Hook] File: ${filePath}`);
+      console.error('[Hook] Consider consolidating into README.md or docs/ directory');
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  process.stdout.write(data);
+});

package/scripts/hooks/evaluate-session.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Continuous Learning - Session Evaluator
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs on Stop hook to extract reusable patterns from Claude Code sessions.
+ * Reads transcript_path from stdin JSON (Claude Code hook input).
+ *
+ * Why Stop hook instead of UserPromptSubmit:
+ * - Stop runs once at session end (lightweight)
+ * - UserPromptSubmit runs every message (heavy, adds latency)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getLearnedSkillsDir,
+  ensureDir,
+  readFile,
+  countInFile,
+  log
+} = require('../lib/utils');
+
+// Read hook input from stdin (Claude Code provides transcript_path via stdin JSON)
+const MAX_STDIN = 1024 * 1024;
+let stdinData = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (stdinData.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - stdinData.length;
+    stdinData += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  main().catch(err => {
+    console.error('[ContinuousLearning] Error:', err.message);
+    process.exit(0);
+  });
+});
+
+async function main() {
+  // Parse stdin JSON to get transcript_path
+  let transcriptPath = null;
+  try {
+    const input = JSON.parse(stdinData);
+    transcriptPath = input.transcript_path;
+  } catch {
+    // Fallback: try env var for backwards compatibility
+    transcriptPath = process.env.CLAUDE_TRANSCRIPT_PATH;
+  }
+
+  // Get script directory to find config
+  const scriptDir = __dirname;
+  const configFile = path.join(scriptDir, '..', '..', 'skills', 'continuous-learning', 'config.json');
+
+  // Default configuration
+  let minSessionLength = 10;
+  let learnedSkillsPath = getLearnedSkillsDir();
+
+  // Load config if exists
+  const configContent = readFile(configFile);
+  if (configContent) {
+    try {
+      const config = JSON.parse(configContent);
+      minSessionLength = config.min_session_length ?? 10;
+
+      if (config.learned_skills_path) {
+        // Handle ~ in path
+        learnedSkillsPath = config.learned_skills_path.replace(/^~/, require('os').homedir());
+      }
+    } catch (err) {
+      log(`[ContinuousLearning] Failed to parse config: ${err.message}, using defaults`);
+    }
+  }
+
+  // Ensure learned skills directory exists
+  ensureDir(learnedSkillsPath);
+
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    process.exit(0);
+  }
+
+  // Count user messages in session (allow optional whitespace around colon)
+  const messageCount = countInFile(transcriptPath, /"type"\s*:\s*"user"/g);
+
+  // Skip short sessions
+  if (messageCount < minSessionLength) {
+    log(`[ContinuousLearning] Session too short (${messageCount} messages), skipping`);
+    process.exit(0);
+  }
+
+  // Signal to Claude that session should be evaluated for extractable patterns
+  log(`[ContinuousLearning] Session has ${messageCount} messages - evaluate for extractable patterns`);
+  log(`[ContinuousLearning] Save learned skills to: ${learnedSkillsPath}`);
+
+  process.exit(0);
+}