cc-dev-template 0.1.46 → 0.1.48

package/bin/install.js

@@ -233,7 +233,7 @@ if (fs.existsSync(mergeSettingsPath)) {
     { file: 'read-guard-hook.json', name: 'Context guard for large reads' },
     { file: 'statusline-config.json', name: 'Custom status line' },
     { file: 'bash-overflow-hook.json', name: 'Bash overflow guard hook' },
-    { file: 'bash-precheck-hook.json', name: 'Bash precheck hook' }
+    { file: 'env-config.json', name: 'Environment variables' }
   ];
 
   configs.forEach(({ file, name }) => {
@@ -251,23 +251,69 @@ if (fs.existsSync(mergeSettingsPath)) {
   });
 }
 
-// Remove deprecated plugins
+// Remove deprecated files and settings
 console.log('\nCleanup:');
+let cleanupPerformed = false;
+
+// Remove deprecated bash wrapper files
+const deprecatedFiles = [
+  path.join(CLAUDE_DIR, 'hooks', 'bash-precheck.sh'),
+  path.join(CLAUDE_DIR, 'hooks', 'bash-wrapper-helper.sh'),
+  path.join(CLAUDE_DIR, 'scripts', 'bash-precheck-hook.json')
+];
+
+deprecatedFiles.forEach(file => {
+  if (fs.existsSync(file)) {
+    fs.unlinkSync(file);
+    console.log(`✓ Removed deprecated ${path.basename(file)}`);
+    cleanupPerformed = true;
+  }
+});
+
+// Remove deprecated hooks from settings.json
 if (fs.existsSync(settingsFile)) {
   try {
     const settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    let settingsModified = false;
+
+    // Remove deprecated code-simplifier plugin
     if (settings.enabledPlugins && settings.enabledPlugins['code-simplifier@claude-plugins-official']) {
       delete settings.enabledPlugins['code-simplifier@claude-plugins-official'];
-      fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
       console.log('✓ Removed deprecated code-simplifier plugin');
-    } else {
-      console.log('  No deprecated plugins to remove');
+      settingsModified = true;
+      cleanupPerformed = true;
+    }
+
+    // Remove bash-precheck hooks from settings
+    if (settings.hooks) {
+      const hookTypes = ['PreToolUse', 'PostToolUse'];
+      hookTypes.forEach(hookType => {
+        if (settings.hooks[hookType] && Array.isArray(settings.hooks[hookType])) {
+          const originalLength = settings.hooks[hookType].length;
+          settings.hooks[hookType] = settings.hooks[hookType].filter(hook => {
+            const command = hook.hooks?.[0]?.command || '';
+            return !command.includes('bash-precheck');
+          });
+          if (settings.hooks[hookType].length < originalLength) {
+            console.log(`✓ Removed deprecated bash-precheck hook from ${hookType}`);
+            settingsModified = true;
+            cleanupPerformed = true;
+          }
+        }
+      });
+    }
+
+
+    if (settingsModified) {
+      fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
     }
   } catch (e) {
-    console.log('  No deprecated plugins to remove');
+    // Ignore errors reading settings
   }
-} else {
-  console.log('  No deprecated plugins to remove');
+}
+
+if (!cleanupPerformed) {
+  console.log('  No deprecated items to remove');
 }
 
 console.log('\n' + '='.repeat(50));

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"
   },
   "files": [
     "bin/",
-    "src/"
+    "src/",
+    "!src/mcp-servers/*/node_modules/",
+    "!src/mcp-servers/*/dist/"
   ],
   "keywords": [
     "claude",

package/src/scripts/env-config.json

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "BASH_MAX_OUTPUT_LENGTH": "1000000"
+  }
+}

package/src/scripts/statusline.js

@@ -161,6 +161,71 @@ function getGitBranch(projectDir) {
   }
 }
 
+/**
+ * Get submodule paths from .gitmodules
+ */
+function getSubmodulePaths(projectDir) {
+  try {
+    const output = execSync('git config --file .gitmodules --get-regexp path', {
+      cwd: projectDir,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    // Parse lines like "submodule.packages/core.path packages/core"
+    return output
+      .trim()
+      .split('\n')
+      .map((line) => line.split(' ')[1])
+      .filter(Boolean);
+  } catch {
+    return []; // No .gitmodules or no submodules
+  }
+}
+
+/**
+ * Get all modules (main + submodules) that have changes
+ * Returns array of { name, path, branch, status }
+ */
+function getModulesWithChanges(projectDir) {
+  const submodulePaths = getSubmodulePaths(projectDir);
+
+  // If no submodules, return null to indicate regular repo
+  if (submodulePaths.length === 0) {
+    return null;
+  }
+
+  const modules = [];
+
+  // Check main repo
+  const mainStatus = getGitStatus(projectDir);
+  const mainStatusStr = mainStatus ? formatGitStatus(mainStatus) : '';
+  if (mainStatusStr) {
+    modules.push({
+      name: 'MAIN',
+      path: projectDir,
+      branch: getGitBranch(projectDir),
+      status: mainStatusStr,
+    });
+  }
+
+  // Check each submodule
+  for (const subPath of submodulePaths) {
+    const fullPath = join(projectDir, subPath);
+    const subStatus = getGitStatus(fullPath);
+    const subStatusStr = subStatus ? formatGitStatus(subStatus) : '';
+    if (subStatusStr) {
+      modules.push({
+        name: basename(subPath).toUpperCase(),
+        path: fullPath,
+        branch: getGitBranch(fullPath),
+        status: subStatusStr,
+      });
+    }
+  }
+
+  return modules;
+}
+
 /**
  * Main function
  */
@@ -237,14 +302,17 @@ function main() {
       ctxDisplay = `CTX: ${greyColor}[${bar}] ${pct}%${DIM_GREY} | ${usedTokens}/${limitTokens}`;
     }
 
-    // Get git information
-    const gitBranch = getGitBranch(data.workspace.project_dir);
-    const gitStatus = getGitStatus(data.workspace.project_dir);
-    const gitStatusStr = gitStatus ? formatGitStatus(gitStatus) : '';
-
     // Multi-line bordered box format
     const width = 56;
 
+    // Helper to create a padded box line
+    const makeBoxLine = (content) => {
+      const plain = content.replace(/\x1b\[[0-9;]*m/g, '');
+      const padding = width - plain.length;
+      const padded = content + ' '.repeat(Math.max(0, padding));
+      return `${DIM_GREY}║ ${padded} ║${RESET}`;
+    };
+
     // Top border with model name (add 2 to match content line width: ║ + space + 56 + space + ║ = 60)
     const modelName = data.model.display_name.toUpperCase();
     const labelWidth = modelName.length + 2; // +2 for brackets
@@ -255,46 +323,69 @@ function main() {
     const maxDirLen = width - 5; // "DIR: " = 5 chars
     const dirName =
       rawDirName.length > maxDirLen ? rawDirName.substring(0, maxDirLen - 3) + '...' : rawDirName;
-    const line0Content = `DIR: ${dirName}`;
-
-    const plainLine0 = line0Content.replace(/\x1b\[[0-9;]*m/g, '');
-    const padding0 = width - plainLine0.length;
-    const paddedLine0 = line0Content + ' '.repeat(Math.max(0, padding0));
-    const line0 = `${DIM_GREY}║ ${paddedLine0} ║${RESET}`;
-
-    // Line 1: Branch + git status (padded to width)
-    let line1Content = '';
-    if (gitBranch) {
-      const branchPrefix = 'BRANCH: ';
-      const branchSuffix = ' ⎇';
-      const gitStatusSpace = gitStatusStr ? ` ${gitStatusStr}` : '';
-
-      const availableSpace = width - branchPrefix.length - branchSuffix.length - gitStatusSpace.length;
-      const displayBranch =
-        gitBranch.length > availableSpace
-          ? gitBranch.substring(0, availableSpace - 3) + '...'
-          : gitBranch;
-
-      line1Content = `${branchPrefix}${displayBranch.toUpperCase()}${branchSuffix}${gitStatusSpace}`;
+    const line0 = makeBoxLine(`DIR: ${dirName}`);
+
+    // Get git information - check for submodules
+    const modulesWithChanges = getModulesWithChanges(data.workspace.project_dir);
+
+    // Build branch/module lines
+    const branchLines = [];
+
+    if (modulesWithChanges === null) {
+      // No submodules - use original single-line format
+      const gitBranch = getGitBranch(data.workspace.project_dir);
+      const gitStatus = getGitStatus(data.workspace.project_dir);
+      const gitStatusStr = gitStatus ? formatGitStatus(gitStatus) : '';
+
+      let line1Content = '';
+      if (gitBranch) {
+        const branchPrefix = 'BRANCH: ';
+        const branchSuffix = ' ⎇';
+        const gitStatusSpace = gitStatusStr ? ` ${gitStatusStr}` : '';
+
+        const availableSpace = width - branchPrefix.length - branchSuffix.length - gitStatusSpace.length;
+        const displayBranch =
+          gitBranch.length > availableSpace
+            ? gitBranch.substring(0, availableSpace - 3) + '...'
+            : gitBranch;
+
+        line1Content = `${branchPrefix}${displayBranch.toUpperCase()}${branchSuffix}${gitStatusSpace}`;
+      } else {
+        line1Content = 'BRANCH: (none)';
+      }
+      branchLines.push(makeBoxLine(line1Content));
+    } else if (modulesWithChanges.length === 0) {
+      // Has submodules but all clean
+      const gitBranch = getGitBranch(data.workspace.project_dir);
+      const branchName = gitBranch ? gitBranch.toUpperCase() : '(none)';
+      branchLines.push(makeBoxLine(`BRANCH: ${branchName} ⎇ (all clean)`));
     } else {
-      line1Content = 'BRANCH: (none)';
+      // Has submodules with changes - one line per module
+      for (const mod of modulesWithChanges) {
+        const branchName = mod.branch ? mod.branch.toUpperCase() : '(none)';
+        const prefix = `[${mod.name}] `;
+        const suffix = ' ⎇';
+        const statusSpace = ` ${mod.status}`;
+
+        const availableSpace = width - prefix.length - suffix.length - statusSpace.length;
+        const displayBranch =
+          branchName.length > availableSpace
+            ? branchName.substring(0, availableSpace - 3) + '...'
+            : branchName;
+
+        branchLines.push(makeBoxLine(`${prefix}${displayBranch}${suffix}${statusSpace}`));
+      }
     }
 
-    const plainLine1 = line1Content.replace(/\x1b\[[0-9;]*m/g, '');
-    const padding1 = width - plainLine1.length;
-    const paddedLine1 = line1Content + ' '.repeat(Math.max(0, padding1));
-    const line1 = `${DIM_GREY}║ ${paddedLine1} ║${RESET}`;
-
-    // Line 2: Context bar (padded to width)
-    const plainCtx = ctxDisplay.replace(/\x1b\[[0-9;]*m/g, '');
-    const padding2 = width - plainCtx.length;
-    const paddedCtx = ctxDisplay + ' '.repeat(Math.max(0, padding2));
-    const line2 = `${DIM_GREY}║ ${paddedCtx} ║${RESET}`;
+    // Context bar line
+    const ctxLine = makeBoxLine(ctxDisplay);
 
     // Bottom border (add 2 to match content line width)
     const bottomBorder = `${DIM_GREY}╚${'═'.repeat(width + 2)}╝${RESET}`;
 
-    console.log(`${topBorder}\n${line0}\n${line1}\n${line2}\n${bottomBorder}`);
+    // Combine all lines
+    const allLines = [topBorder, line0, ...branchLines, ctxLine, bottomBorder];
+    console.log(allLines.join('\n'));
   } catch (error) {
     // Log error for debugging (goes to stderr, not visible in status line)
     console.error(`Status line error: ${error.message}`);

package/src/hooks/bash-precheck-hook.json

@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$HOME/.claude/hooks/bash-precheck.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

package/src/hooks/bash-precheck.sh

@@ -1,117 +0,0 @@
-#!/bin/bash
-# bash-precheck.sh - PreToolUse hook to wrap Bash commands with output limiting
-#
-# Intercepts Bash commands before execution and wraps them to:
-# 1. Capture output to temp file
-# 2. If output exceeds threshold, save and return truncated version
-#
-# This ACTUALLY prevents large outputs from consuming context.
-# Compatible with bash and zsh on macOS and Linux.
-
-set -e
-
-# Configuration
-MAX_CHARS=${BASH_OVERFLOW_MAX_CHARS:-20000}
-OVERFLOW_DIR="${HOME}/.claude/bash-overflow"
-
-# Read hook input from stdin
-input=$(cat)
-
-# Parse tool name and command
-tool_name=$(echo "$input" | jq -r '.tool_name // empty')
-
-# Only process Bash tool
-if [[ "$tool_name" != "Bash" ]]; then
-    exit 0
-fi
-
-# Get the original command
-original_cmd=$(echo "$input" | jq -r '.tool_input.command // empty')
-
-# Skip if empty
-if [[ -z "$original_cmd" ]]; then
-    exit 0
-fi
-
-# Skip commands that are already piped to head/tail or are simple commands
-if [[ "$original_cmd" =~ \|[[:space:]]*(head|tail|wc|grep.*-c) ]]; then
-    exit 0
-fi
-
-# Skip very short commands (likely simple operations)
-if [[ ${#original_cmd} -lt 10 ]]; then
-    exit 0
-fi
-
-# Create overflow directory
-mkdir -p "$OVERFLOW_DIR"
-
-# Generate unique filename
-timestamp=$(date +%Y%m%d_%H%M%S)
-rand_suffix=$RANDOM
-overflow_file="$OVERFLOW_DIR/bash_output_${timestamp}_${rand_suffix}.txt"
-temp_file="/tmp/claude_bash_${timestamp}_${rand_suffix}.tmp"
-
-# Escape the original command for embedding in the wrapper
-# Use base64 to safely embed arbitrary commands
-original_cmd_b64=$(echo "$original_cmd" | base64)
-
-# Create wrapper that uses temp file approach (more portable)
-read -r -d '' wrapped_cmd << 'WRAPPER_EOF' || true
-__cmd_b64="BASE64_CMD_HERE"
-__cmd=$(echo "$__cmd_b64" | base64 -d)
-__tmpfile="TEMP_FILE_HERE"
-__overflow="OVERFLOW_FILE_HERE"
-__max=MAX_CHARS_HERE
-
-# Run command and capture to temp file
-eval "$__cmd" > "$__tmpfile" 2>&1
-__exit_code=$?
-
-# Check size
-__size=$(wc -c < "$__tmpfile" | tr -d ' ')
-
-if [ "$__size" -gt "$__max" ]; then
-    # Save full output
-    cp "$__tmpfile" "$__overflow"
-    __lines=$(wc -l < "$__tmpfile" | tr -d ' ')
-    __tokens=$((__size / 4))
-
-    echo "=== OUTPUT TRUNCATED (${__lines} lines, ~${__tokens} tokens) ==="
-    echo ""
-    echo "--- First 5 lines ---"
-    head -n 5 "$__tmpfile"
-    echo ""
-    echo "--- Last 5 lines ---"
-    tail -n 5 "$__tmpfile"
-    echo ""
-    echo "=== Full output saved to: $__overflow ==="
-    echo "Use Grep(pattern, path) or Read(file_path, offset, limit) to explore"
-else
-    cat "$__tmpfile"
-fi
-
-rm -f "$__tmpfile"
-exit $__exit_code
-WRAPPER_EOF
-
-# Substitute placeholders
-wrapped_cmd="${wrapped_cmd//BASE64_CMD_HERE/$original_cmd_b64}"
-wrapped_cmd="${wrapped_cmd//TEMP_FILE_HERE/$temp_file}"
-wrapped_cmd="${wrapped_cmd//OVERFLOW_FILE_HERE/$overflow_file}"
-wrapped_cmd="${wrapped_cmd//MAX_CHARS_HERE/$MAX_CHARS}"
-
-# Return the modified command
-cat << EOF
-{
-  "hookSpecificOutput": {
-    "hookEventName": "PreToolUse",
-    "permissionDecision": "allow",
-    "updatedInput": {
-      "command": $(echo "$wrapped_cmd" | jq -Rs .)
-    }
-  }
-}
-EOF
-
-exit 0