cc-dev-template 0.1.46 → 0.1.49

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.49",
   "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/skills/creating-agent-skills/SKILL.md

@@ -1,54 +1,18 @@
 ---
 name: creating-agent-skills
-description: Expert guidance for creating, modifying, and auditing Claude Code skills. Use when the user asks to "create a skill", "build a new skill", "audit skills", "review my skills", "update a skill", "modify a skill", "improve a skill", or mentions skill development, SKILL.md files, or progressive disclosure.
+description: Expert guidance for creating and fixing Claude Code skills. Use when the user asks to "create a skill", "build a new skill", "fix a skill", "audit skills", "review my skills", "update a skill", "modify a skill", "improve a skill", or mentions skill development, SKILL.md files, or progressive disclosure.
 ---
 
 # Creating Agent Skills
 
 ## What To Do Now
 
-Ask what the user wants to do with skills.
+Ask the user what they need.
 
-Use `AskUserQuestion`:
-- **Create a new skill** - Build a skill through guided conversation
-- **Audit existing skills** - Review skills for best practices compliance
-- **Modify a skill** - Update or improve an existing skill
-- **Something else** - Free-form request
-
-## Route to Workflow
-
-Based on choice, read the appropriate workflow:
-
-| Choice | Action |
+| Intent | Action |
 |--------|--------|
-| Create | Read `references/create.md` |
-| Audit | Read `references/audit.md` |
-| Modify | Read `references/modify.md` |
-| Something else | Help find the right approach |
-
-## Essential Knowledge
-
-**A skill IS a prompt.** When activated, Claude reads SKILL.md. It must contain instructions, not documentation about the skill.
-
-**Progressive disclosure.** SKILL.md should be lean (<150 lines). Heavy content goes in references/. This keeps context efficient.
-
-**The test:** After reading SKILL.md, would Claude know what to DO? If it only knows what the skill is about, it's written wrong.
-
-For complete principles, workflows load `references/principles.md` as needed.
-
-## Quick Reference
-
-**Skill locations:**
-
-| Level | Path |
-|-------|------|
-| User | `~/.claude/skills/` |
-| Project | `.claude/skills/` |
-
-**Bundled scripts:**
-- `scripts/find-skills.js` - Discover all installed skills
-- `scripts/validate-skill.js` - Validate a skill's structure
-
-## Requirements
+| Create a new skill | Read `references/create-step-1-understand.md` |
+| Fix, improve, audit, or modify an existing skill | Read `references/fix-step-1-diagnose.md` |
 
-- Node.js (for validation scripts)
+If the user says "audit my skills", that is the fix path.
+If they mention a specific skill that needs changes, that is also the fix path.

package/src/skills/creating-agent-skills/references/create-step-1-understand.md

@@ -0,0 +1,42 @@
+# Step 1: Understand the Domain
+
+The skill's quality depends entirely on understanding the domain. Start a conversation with the user.
+
+## What To Uncover
+
+- **The task** they want to standardize — what do they do repeatedly that they want encoded?
+- **Domain knowledge** Claude does not naturally have — terminology, patterns, edge cases, gotchas
+- **Why certain approaches work** — not just what the steps are, but the reasoning behind them
+- **Concrete examples** of the task done well — ask for real examples or walk-throughs
+- **Common mistakes** people make when doing this task
+
+## How To Have This Conversation
+
+If the user already provided comprehensive context (a detailed spec, all the steps, domain knowledge), verify your understanding and move on — do not re-ask what they already answered. If the context is thin or ambiguous, have a real conversation.
+
+Ask one or two questions at a time. This should feel like a conversation, not a form.
+
+Good questions:
+- "Walk me through how you do this today."
+- "What's the most important thing to get right?"
+- "What mistakes do people commonly make?"
+- "What would an expert know that a beginner wouldn't?"
+- "Can you show me an example of this done well?"
+
+Ask follow-up questions. Dig into the WHY behind their answers. If they say "always do X before Y", ask why that order matters.
+
+## If the Task Is Non-Obvious
+
+If this is a domain where Claude would not naturally know how to proceed — research it. Look at examples. Try to figure out how you would approach the task yourself. The skill author needs to understand the domain, not just record what the user says.
+
+Use the Explore agent or web search if the domain requires knowledge you lack.
+
+## When To Move On
+
+Move on when all of these are true:
+- You can articulate what makes this task hard or nuanced
+- You have enough domain knowledge to write instructions a fresh Claude instance could follow
+- You understand WHY the approaches work, not just WHAT they are
+- The user confirms you understand their needs
+
+Read `references/create-step-2-design.md`.

package/src/skills/creating-agent-skills/references/create-step-2-design.md

@@ -0,0 +1,113 @@
+# Step 2: Design the Skill
+
+Based on what you learned in the conversation, design the skill's structure before writing anything.
+
+## Determine the Name
+
+- Hyphen-case: lowercase letters, numbers, and hyphens only
+- Prefer gerund form: `processing-pdfs`, `creating-reports`, `reviewing-code`
+- Must match the directory name
+- Max 64 characters
+
+## Determine the Skill Type
+
+There are two types. Pick one:
+
+**Informational** — A single SKILL.md file that captures knowledge, conventions, or best practices. No sequential workflow. The agent absorbs it and applies it to whatever it's doing. Example: a `prompting` skill that teaches how to write good prompts.
+
+**Procedural** — A chain of step files for a sequential process. SKILL.md routes to step 1. Step 1 chains to step 2. Each step file covers ONE phase. The agent only sees the current step. Example: a skill that downloads a video, transcribes it, formats it, and summarizes it — four distinct phases, four files.
+
+**How to decide:** If the skill describes a process with distinct sequential phases, it is procedural. If it captures principles or knowledge applied whenever relevant, it is informational.
+
+## Design the Frontmatter
+
+Every skill has YAML frontmatter. Required and optional fields:
+
+### Required
+
+| Field | Rules |
+|-------|-------|
+| `name` | Hyphen-case, matches directory name, max 64 chars |
+| `description` | Third person, quoted trigger phrases, WHEN to use not HOW it works, max 1024 chars |
+
+### Optional
+
+| Field | Purpose |
+|-------|---------|
+| `argument-hint` | Placeholder shown after slash command (e.g., `[issue-number]`, `[filename]`) |
+| `disable-model-invocation` | Set `true` to prevent Claude from auto-activating — use for side-effect workflows like deploy or commit |
+| `user-invocable` | Set `false` to hide from the `/` menu — use for background knowledge skills |
+| `allowed-tools` | Restrict which tools the skill can use (e.g., `Read, Grep, Glob` for read-only) |
+| `model` | Override the model used when this skill is active |
+| `context` | Set `fork` to run in an isolated sub-agent context |
+| `agent` | Sub-agent type when `context: fork` is set (`Explore`, `Plan`, `general-purpose`, or custom) |
+| `hooks` | Lifecycle hooks scoped to this skill |
+
+### String Substitutions Available in Skill Content
+
+| Syntax | What It Does |
+|--------|--------------|
+| `$ARGUMENTS` | Full argument string passed after `/skill-name` |
+| `$ARGUMENTS[N]` or `$N` | Positional argument (0-based) |
+| `${CLAUDE_SESSION_ID}` | Current session ID |
+| `` !`command` `` | Output of a shell command, injected at activation time before Claude sees the content |
+
+## Craft the Description
+
+The description determines when Claude activates the skill. This is the most important piece of metadata.
+
+Collect 5-10 trigger phrases from the user: "When you need this skill, what would you say to Claude?"
+
+Combine into a description that:
+- Uses third person: "This skill should be used when..."
+- Includes the actual trigger phrases in quotes
+- Focuses on WHEN to use, not HOW it works
+- Stays under 1024 characters
+
+**Key insight:** If the description explains too much about WHAT the skill does, Claude believes it already knows enough and will not activate. Keep it about WHEN.
+
+**Context budget note:** Skill descriptions load at startup and share a character budget (default 15,000 chars across all skills). Keep descriptions tight — they cost tokens every session.
+
+## Plan the File Layout
+
+**For informational skills:**
+```
+skill-name/
+└── SKILL.md
+```
+Optionally add `references/` for depth that is not always needed.
+
+**For procedural skills:**
+```
+skill-name/
+├── SKILL.md                    # Routes to step 1
+└── references/
+    ├── step-1-[name].md        # Chains to step 2
+    ├── step-2-[name].md        # Chains to step 3
+    └── step-3-[name].md        # Final step
+```
+
+**When to add `scripts/`:** Deterministic operations that need reliability — validation, code generation, file operations.
+
+**When to add `templates/`:** Boilerplate files that get copied or modified by the agent.
+
+## For Procedural Skills: Plan the Steps
+
+List out the steps. Each step becomes one markdown file in `references/`. For each step, determine:
+- What the agent does during this step
+- What signals the step is complete (the chain condition)
+- What the next step is
+
+## Confirm With the User
+
+Present the design:
+- Name
+- Type (informational or procedural)
+- Frontmatter configuration
+- Description text
+- File layout
+- For procedural: the step breakdown
+
+Ask: "Does this design look right?"
+
+Read `references/create-step-3-write.md` when the design is confirmed.