claude-smith 3.2.0 → 3.3.0

package/README.ko.md

@@ -142,6 +142,7 @@ Claude Code 세션
 | `/smith-report` | 상세 규정 준수 리포트 |
 | `/smith-check` | 설치 검증 |
 | `/smith-plan` | 분해 계획 템플릿 생성 |
+| `/smith-decompose` | 복잡한 작업을 위한 5단계 가이드 분해 |
 | `/smith-update` | 버전 체크 + 업그레이드 |
 
 ## 명령어

package/README.md

@@ -142,6 +142,7 @@ After installation, these commands are available in Claude Code:
 | `/smith-report` | Detailed compliance report |
 | `/smith-check` | Validate installation |
 | `/smith-plan` | Generate decomposition plan template |
+| `/smith-decompose` | Guided 5-step problem decomposition for complex tasks |
 | `/smith-update` | Check for updates and upgrade |
 
 ## Commands

package/bin/cli.mjs

@@ -403,14 +403,14 @@ function check() {
 
   // Check commands
   const commandsDir = join(cwd, '.claude', 'commands');
-  const expectedCommands = ['smith.md', 'smith-report.md', 'smith-check.md', 'smith-plan.md'];
+  const expectedCommands = ['smith.md', 'smith-report.md', 'smith-check.md', 'smith-plan.md', 'smith-decompose.md'];
   const missingCommands = expectedCommands.filter(c => !existsSync(join(commandsDir, c)));
-  results.commands = { installed: 4 - missingCommands.length, total: 4, missing: missingCommands };
+  results.commands = { installed: 5 - missingCommands.length, total: 5, missing: missingCommands };
 
   if (!ciMode) {
     console.log(missingCommands.length === 0
-      ? `✅ Commands: 4/4 installed`
-      : `❌ Commands: ${4 - missingCommands.length}/4 (missing: ${missingCommands.join(', ')})`);
+      ? `✅ Commands: 5/5 installed`
+      : `❌ Commands: ${5 - missingCommands.length}/5 (missing: ${missingCommands.join(', ')})`);
   }
   if (missingCommands.length > 0) results.ok = false;
 

package/hooks/plan-guard.mjs

@@ -88,6 +88,18 @@ const isOmc = isOmcAutoMode(process.cwd());
 const warnAt = isOmc ? (config.warnAt || 5) * 2 : (config.warnAt || 5);
 const blockAt = isOmc ? (config.blockAt || 10) * 2 : (config.blockAt || 10);
 
+// Early suggestion on first code edit (gentle, non-blocking)
+if (count === 1) {
+  notifyUser(config.notify, 'Plan Guard', 'warn', '첫 코드 편집 — 복잡한 작업이면 /smith-decompose 먼저');
+  const output = JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: `🕵️ Smith > Plan Guard: First code file edit detected without a plan. If this is a complex or abstract task, consider running /smith-decompose first to break it down into verifiable units.\n💡 Simple task? Ignore this and continue. Complex task? Decompose first, implement second.`
+    }
+  });
+  process.stdout.write(output);
+}
+
 // Block if threshold reached
 if (count >= blockAt) {
   recordEvent(sessionId, 'plan-guard', 'block');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-smith",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Claude Code workflow enforcement CLI - forging coding discipline into every session",
   "type": "module",
   "scripts": {

package/templates/commands/smith-decompose.md

@@ -0,0 +1,63 @@
+Decompose a complex or abstract request into verifiable work units.
+
+Follow this 5-step framework strictly. Do NOT skip steps or jump to implementation.
+
+## Step 1: Essence Extraction
+
+Ask yourself: **"What is the user actually trying to achieve?"**
+
+- Strip away implementation details and restate the core problem in one sentence
+- Identify the success criteria: "How will we know this is done?"
+- Output: `Core Problem: ...` and `Success Criteria: ...`
+
+## Step 2: Uncertainty Map
+
+List what you DON'T know. Be honest about assumptions.
+
+| What I Know | What I Assume | What I Don't Know |
+|-------------|---------------|-------------------|
+| (facts)     | (guesses)     | (unknowns)        |
+
+Every item in "Assume" and "Don't Know" is a candidate for a user question.
+
+## Step 3: Clarifying Questions
+
+Use the AskUserQuestion tool to ask 1-2 targeted questions based on Step 2.
+
+Rules:
+- Ask about the MOST impactful unknowns only (not everything)
+- Provide 2-3 concrete options per question with trade-offs
+- Include your recommendation
+- WAIT for user answers before proceeding to Step 4
+
+## Step 4: Unit Decomposition
+
+Break the work into independently verifiable units:
+
+For each unit:
+- **Name**: Short descriptive name
+- **Responsibility**: One sentence (if it needs two, split the unit)
+- **Inputs/Outputs**: What it receives, what it produces
+- **Verification**: Specific test or check that proves it works
+- **Files**: Create/modify/test file paths
+
+Quality checks:
+- Each unit has exactly ONE responsibility
+- Dependencies are unidirectional (no cycles)
+- Removing any unit doesn't break the others
+- Each unit can be verified in isolation
+
+## Step 5: Plan File Generation
+
+Generate `docs/plans/YYYY-MM-DD-<topic>.md` (or `plan.md`) with:
+
+1. Goal (from Step 1)
+2. Decisions (from Step 3 answers)
+3. Unit list with dependency graph
+4. Implementation order (leaf-first: fewest dependencies first)
+5. Per-unit tasks at 2-5 minute granularity
+
+After generating the plan, report to the user:
+- How many units and tasks were created
+- Estimated implementation order
+- Which unit to start with and why