cc-discipline 2.8.0 → 2.9.0

package/bin/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// cc-discipline CLI entry point (cross-platform)
+// Detects platform and spawns bash with correct paths
+
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const PKG_DIR = path.resolve(__dirname, '..');
+const args = process.argv.slice(2);
+
+// Find bash executable
+function findBash() {
+    // Unix: bash is always available
+    if (process.platform !== 'win32') return 'bash';
+
+    // Windows: try common Git Bash locations
+    const candidates = [
+        'C:\\Program Files\\Git\\bin\\bash.exe',
+        'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+        process.env.PROGRAMFILES + '\\Git\\bin\\bash.exe',
+    ];
+
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) return candidate;
+    }
+
+    // Try PATH
+    try {
+        execSync('bash --version', { stdio: 'ignore' });
+        return 'bash';
+    } catch (e) {
+        console.error('Error: bash not found. Please install Git for Windows (https://git-scm.com/download/win)');
+        console.error('Git Bash is required to run cc-discipline on Windows.');
+        process.exit(1);
+    }
+}
+
+const bash = findBash();
+
+// Convert Windows path to Unix-style for bash
+function toUnixPath(p) {
+    if (process.platform !== 'win32') return p;
+    // C:\Users\foo → /c/Users/foo
+    return p.replace(/\\/g, '/').replace(/^([A-Za-z]):/, (_, drive) => '/' + drive.toLowerCase());
+}
+
+// Route subcommands
+const command = args[0] || 'init';
+const restArgs = args.slice(1);
+
+let script;
+let scriptArgs;
+
+switch (command) {
+    case 'init':
+        script = path.join(PKG_DIR, 'init.sh');
+        scriptArgs = restArgs;
+        break;
+    case 'upgrade':
+        script = path.join(PKG_DIR, 'init.sh');
+        scriptArgs = ['--auto', ...restArgs];
+        break;
+    case 'status':
+        script = path.join(PKG_DIR, 'lib', 'status.sh');
+        scriptArgs = [];
+        break;
+    case 'doctor':
+        script = path.join(PKG_DIR, 'lib', 'doctor.sh');
+        scriptArgs = [];
+        break;
+    case 'add-stack':
+        if (restArgs.length === 0) {
+            console.log('Usage: cc-discipline add-stack <numbers>');
+            console.log('  e.g.: cc-discipline add-stack 3 4');
+            process.exit(1);
+        }
+        script = path.join(PKG_DIR, 'init.sh');
+        scriptArgs = ['--stack', restArgs.join(' '), '--no-global'];
+        break;
+    case 'remove-stack':
+        script = path.join(PKG_DIR, 'lib', 'stack-remove.sh');
+        scriptArgs = restArgs;
+        break;
+    case '-v':
+    case '--version':
+    case 'version':
+        const pkg = require(path.join(PKG_DIR, 'package.json'));
+        console.log(`cc-discipline v${pkg.version}`);
+        process.exit(0);
+    case '-h':
+    case '--help':
+    case 'help':
+        const ver = require(path.join(PKG_DIR, 'package.json')).version;
+        console.log(`cc-discipline v${ver} — Discipline framework for Claude Code
+
+Usage: cc-discipline <command> [options]
+
+Commands:
+  init [options]        Install discipline into current project (default)
+  upgrade               Upgrade rules/hooks (shortcut for init --auto)
+  add-stack <numbers>   Add stack rules (e.g., add-stack 3 4)
+  remove-stack <numbers> Remove stack rules
+  status                Show installed version, stacks, and hooks
+  doctor                Check installation integrity
+  version               Show version
+
+Init options:
+  --auto                Non-interactive with defaults
+  --stack <choices>     Stack selection: 1-7, space-separated
+  --name <name>         Project name (default: directory name)
+  --global              Install global rules to ~/.claude/CLAUDE.md
+  --no-global           Skip global rules install
+
+Stacks:
+  1=RTL  2=Embedded  3=Python  4=JS/TS  5=Mobile  6=Fullstack  7=General
+
+Examples:
+  npx cc-discipline                           # Interactive setup
+  npx cc-discipline init --auto               # Non-interactive defaults
+  npx cc-discipline init --auto --stack "3 4"  # Python + JS/TS
+  npx cc-discipline upgrade                   # Upgrade to latest
+  npx cc-discipline status                    # Check what's installed
+  npx cc-discipline doctor                    # Diagnose issues`);
+        process.exit(0);
+    default:
+        console.error(`Unknown command: ${command}`);
+        console.error("Run 'cc-discipline --help' for usage");
+        process.exit(1);
+}
+
+// Run the bash script
+const unixScript = toUnixPath(script);
+const env = {
+    ...process.env,
+    CC_DISCIPLINE_PKG_DIR: process.platform === 'win32' ? toUnixPath(PKG_DIR) : PKG_DIR,
+};
+
+const result = spawnSync(bash, [unixScript, ...scriptArgs], {
+    stdio: 'inherit',
+    env,
+    cwd: process.cwd(),
+});
+
+process.exit(result.status || 0);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cc-discipline",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "Discipline framework for Claude Code — rules, hooks, and agents that keep AI on track",
   "bin": {
-    "cc-discipline": "bin/cli.sh"
+    "cc-discipline": "bin/cli.js"
   },
   "files": [
     "bin/",

package/templates/.claude/skills/investigate/SKILL.md

@@ -9,6 +9,7 @@ Determine which mode based on user input:
 
 - **Research mode** — User gives a topic/question with no existing proposal. Goal: build comprehensive understanding before forming an opinion.
 - **Review mode** — User gives an existing document, proposal, or design. Goal: stress-test it from multiple angles, find blind spots and weaknesses.
+- **Simulate mode** — User gives a plan and wants to "dry run" it. Goal: walk through execution step by step, let hidden problems surface naturally.
 
 State which mode you're using and why.
 
@@ -126,6 +127,59 @@ Don't just tear it apart. For each issue found, suggest what would fix it.
 
 ---
 
+# Simulate Mode
+
+You have a plan or proposal. Instead of analyzing it on paper, **walk through it as if you're actually executing it**, step by step. Let problems surface naturally.
+
+## Step 1: Extract execution steps
+
+Read the plan and break it into concrete sequential steps. For each step, identify:
+- What it requires (inputs, resources, preconditions)
+- What it produces (outputs, state changes)
+- What it assumes
+
+Present the steps and confirm with the user: "Is this the execution sequence?"
+
+## Step 2: Assign simulation agents
+
+Spawn one agent per phase or critical step. Each agent:
+- **Actually attempts to execute** (or traces through execution) of their assigned step
+- Works with real files, real code, real environment where possible
+- If can't actually execute (e.g., deployment plan), does a detailed walkthrough: "At this point I would need X, but looking at the current state, X is not available because..."
+- Reports for each step:
+  - **Went as planned** — step worked / would work as described
+  - **Missing precondition** — "Step 3 assumes X exists, but step 2 doesn't create it"
+  - **Harder than expected** — "This was described as 'configure Y' but actually requires Z, which takes much longer"
+  - **Hidden dependency** — "This step silently depends on A, which the plan doesn't mention"
+  - **Order problem** — "This needs to happen before step N, not after"
+  - **Ambiguity** — "The plan says 'set up the database' but doesn't specify which schema, migration, or seed data"
+
+## Step 3: Compile discoveries
+
+After all agents return, compile a simulation report:
+
+### Execution timeline
+Show the steps as actually executed (vs. as planned). Highlight where reality diverged from plan.
+
+### Issues discovered
+For each issue:
+- **Severity**: blocker / significant / minor
+- **When discovered**: which step
+- **Root cause**: why the plan missed this
+- **Fix**: specific change to the plan
+
+### Missing steps
+Steps that the plan didn't include but simulation revealed are necessary.
+
+### Revised plan
+Present the original plan with all fixes, missing steps, and reordering applied. Mark what changed and why.
+
+## Step 4: Present to user
+
+Show the simulation report. Let the user decide which fixes to adopt. The revised plan is a suggestion, not a mandate.
+
+---
+
 ## When to use this skill
 
 - Researching a technology choice or architectural decision
@@ -133,5 +187,6 @@ Don't just tear it apart. For each issue found, suggest what would fix it.
 - Evaluating a migration or major refactor
 - **Reviewing an existing proposal, RFC, design doc, or plan**
 - **Stress-testing your own plan before presenting it to stakeholders**
+- **Simulating execution of a plan before committing to it — technical, engineering, or operational**
 - Any situation where you catch yourself going deep on one angle and ignoring others
 - When the user says "you're being narrow" or "what about X?" — that's a sign you needed this from the start