@simplysm/sd-claude 13.0.76 → 13.0.77

package/claude/skills/sd-worktree/SKILL.md

@@ -6,128 +6,73 @@ model: haiku
 
 # sd-worktree
 
-## CRITICAL SAFETY RULES — MERGE & STASH
-
-**These rules are ABSOLUTE. No exceptions. Applies to ALL modes (yolo, normal, plan, etc.).**
-
-1. **NEVER run `git stash drop`, `git stash pop`, or `git stash clear`.**
-   - If you stashed something, ONLY use `git stash apply` (which keeps the stash intact).
-   - If stash is no longer needed, ASK the user before dropping it.
-
-2. **If `merge` fails or produces conflicts → STOP IMMEDIATELY and show this message:**
-   ```
-   ⚠️ A problem occurred during merge.
-   Please proceed with the merge manually.
-   (Error details: <print error/conflict info as-is>)
-   ```
-   - Show this message in the system's configured language.
-   - Do NOT attempt to resolve conflicts yourself.
-   - Do NOT run `git merge --abort` without asking.
-   - Do NOT proceed to `clean` after a failed merge.
-   - Do NOT retry or work around the error.
-   - Just show the message above and STOP. Do nothing else.
-
-3. **If `rebase` fails or produces conflicts → STOP IMMEDIATELY and show this message:**
-   ```
-   ⚠️ A problem occurred during rebase.
-   Please proceed with the rebase manually.
-   (Error details: <print error/conflict info as-is>)
-   ```
-   - Show this message in the system's configured language.
-   - Same rules as merge. Do NOT auto-resolve. Just show the message and STOP.
-
-4. **NEVER run destructive git commands during worktree workflows:**
-   - `git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -f`
-   - `git branch -D` (force delete) — only `-d` (safe delete) is allowed
-   - `git stash drop`, `git stash pop`, `git stash clear`
-
-5. **Before ANY merge/rebase, verify:**
-   - Both main and worktree have NO uncommitted changes (`git status --porcelain`)
-   - If uncommitted changes exist → ask the user (do NOT auto-stash)
-
-6. **After merge completes, verify success before proceeding:**
-   - Check `git status` — if merge conflicts exist, STOP and report
-   - Do NOT proceed to `clean` until merge is confirmed successful
-
-**Violation of these rules causes IRREVERSIBLE DATA LOSS.**
-
-## Overview
-
-Create, merge, and clean up git worktrees under `.worktrees/`. Uses the current branch of the main working tree as the source branch.
-
-**Important**: Claude Code's working directory (cd) shifts between main and worktree, so always verify the cd location before and after each command.
-
-## Target Worktree Resolution
-
-For all commands, the target worktree name is resolved in this order:
-
-1. Explicitly provided in args → use as-is
-2. Current cd is inside `.worktrees/<name>/` → use that `<name>` (auto-detected)
-3. Neither applies → ask the user
-
-## Commands
-
-### add — Create a worktree
-
-Take a work description from args, determine a kebab-case name, then run:
-
-```bash
-# Run from main
-node .claude/skills/sd-worktree/sd-worktree.mjs add <name>
-cd .worktrees/<name>   # Move into the worktree
+Branch-isolated workflow using git worktrees.
+
+## Flow
+
+```mermaid
+flowchart TD
+    START([sd-worktree invoked]) --> ADD
+
+    subgraph ADD [add]
+        A1["git worktree add .worktrees/NAME -b NAME"]
+        A1 -->|fail| HALT
+        A1 -->|ok| A2[detect package manager]
+        A2 --> A3["pm install (cwd: .worktrees/NAME)"]
+        A3 -->|fail| HALT
+        A3 -->|ok| A4["cd .worktrees/NAME"]
+    end
+
+    A4 --> WORK["work + commit inside worktree"]
+    WORK --> MERGE
+
+    subgraph MERGE [merge]
+        M0["cd PROJECT_ROOT"]
+        M0 --> M1["git merge NAME --no-ff (cwd: PROJECT_ROOT)"]
+        M1 -->|fail| HALT
+        M1 -->|ok| M2[merge complete]
+    end
+
+    M2 --> CLEAN
+
+    subgraph CLEAN [clean]
+        C1{"cwd inside worktree?"}
+        C1 -->|yes| HALT
+        C1 -->|no| C2["rm -rf .worktrees/NAME (bash)"]
+        C2 --> C3["git worktree prune"]
+        C3 --> C4["git branch -d NAME"]
+        C4 -->|fail| HALT
+        C4 -->|ok| C5[done]
+    end
+
+    HALT([HALT - AskUserQuestion])
 ```
 
-- All subsequent work should be done inside the worktree
-
-### rebase — Rebase onto main branch
+## Rules
 
-```bash
-# Can be run from inside the worktree
-node .claude/skills/sd-worktree/sd-worktree.mjs rebase [name]
-```
-
-- Rebases the worktree branch onto the latest commit of the main branch
-- Errors if uncommitted changes exist → commit or stash first
-- Use when you want a clean history before merging
-- **If rebase fails or conflicts → STOP. Report to user. Do NOT auto-resolve.**
+### HALT
 
-### merge — Merge into main branch
+When any step reaches **fail** or **HALT**:
 
-```bash
-# Can be run from inside the worktree (script sets cwd to main)
-node .claude/skills/sd-worktree/sd-worktree.mjs merge [name]
-```
+1. Show the error message to the user as-is
+2. Ask the user how to proceed via `AskUserQuestion`
+3. Do **nothing** until the user responds
 
-- Merges the worktree branch into the main working tree's current branch with `--no-ff`
-- Errors if uncommitted changes exist → commit or stash first
-- After merge, always `cd <project-root>` (required for subsequent clean)
+Manual git merge, git stash, git reset, git clean, or **any workaround is forbidden**. Yolo mode does NOT override HALT.
 
-**MERGE SAFETY PROTOCOL:**
-1. Before merge: check BOTH main and worktree for uncommitted changes
-2. If the script exits with non-zero → show "Please proceed with the merge manually." message (in system language) and STOP.
-3. After merge: run `git status` in main to confirm no conflicts
-4. If conflicts or errors → show "Please proceed with the merge manually." message (in system language) and STOP.
-5. Only proceed to `clean` after confirming merge was fully successful
+### Worktree location
 
-### clean — Remove worktree and delete branch
+All worktrees MUST be created under **`.worktrees/`** (project root).
 
-```bash
-# Must cd to main first (worktree directory will be deleted)
-cd <project-root>
-node .claude/skills/sd-worktree/sd-worktree.mjs clean <name>
-```
+### Package manager detection
 
-- Runs `git worktree remove` + `git branch -d`
-- Script blocks execution if run from inside the worktree → must cd to main first
+| File | PM |
+|---|---|
+| `pnpm-lock.yaml` | pnpm |
+| `yarn.lock` | yarn |
+| `package-lock.json` | npm |
+| `bun.lockb` / `bun.lock` | bun |
 
-## Full Workflow Example
+### clean: use rm -rf
 
-```
-(main: 13.x)  → /sd-worktree add modal-migration
-               → cd .worktrees/modal-migration
-(worktree)    → ... work ...
-(worktree)    → /sd-worktree rebase          # (optional) rebase onto latest main
-(worktree)    → /sd-worktree merge
-(worktree)    → cd <project-root>
-(main: 13.x)  → /sd-worktree clean modal-migration
-```
+`git worktree remove` almost always fails on Windows due to file locks. Use `rm -rf` (bash) + `git worktree prune` instead.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-claude",
-  "version": "13.0.76",
+  "version": "13.0.77",
   "description": "Simplysm Claude Code CLI — asset installer",
   "author": "simplysm",
   "license": "Apache-2.0",

package/claude/skills/sd-review/code-simplifier-prompt.md

@@ -1,95 +0,0 @@
-# Code Simplifier Prompt
-
-Template for `Agent(general-purpose)`. Fill in `[TARGET_PATH]`.
-
-```
-You are analyzing code for structural simplification opportunities.
-Your question: "Can this code be simpler without changing its behavior?"
-
-## Target
-
-Analyze ALL source files at [TARGET_PATH].
-
-## Step 1: List all source files
-
-Use Glob to list all .ts/.tsx files under the target path (exclude node_modules, dist).
-
-## Step 2: Understand the structure
-
-Read the following reference files for project conventions:
-- `CLAUDE.md` — project overview and conventions
-- `.claude/rules/sd-refs-linker.md` — reference guide linking to detailed docs per topic (read relevant refs based on the target code)
-
-Then:
-- Map module dependencies and abstraction layers
-- Compare whether similar-role files use consistent patterns
-- Identify complexity hotspots: deep nesting, long functions, complex conditionals
-
-## Step 3: Find refactoring opportunities
-
-Look for:
-- Unnecessary complexity: over-abstraction, needless indirection, complex generics that could be simpler
-- Duplication: same logic repeated across files, similar functions that could be unified
-- Readability: hard-to-follow control flow, unclear variable names, implicit behavior
-- File structure: too many files for simple concepts, or too many responsibilities in one file
-- Coupling: changes that would cascade widely, tightly coupled modules
-
-## CRITICAL — Scope boundaries
-
-Do NOT report ANY of the following. These are OUT OF SCOPE:
-- Bugs, security issues, logic errors, race conditions → that's code review
-- Naming consistency, API design, type quality (including `any` types) → that's API review
-- Code language violations (Korean comments, non-English strings) → that's lint
-- Documentation gaps (missing JSDoc, missing comments, undocumented behavior) → that's documentation
-- Style preferences (property shorthand, `else` after `return`, import ordering, formatting)
-- Performance optimization (unless the fix is ALSO a structural improvement)
-- Magic numbers with clear adjacent comments
-- Small interface duplication (< 10 fields) where extraction adds indirection without real benefit
-- Issues in code OUTSIDE the target path
-
-**Test each finding:** "Is this about CODE STRUCTURE, or about something else (bugs, conventions, docs, performance)?" If something else → drop it.
-
-## Step 4: Self-verify before reporting
-
-Before including ANY finding:
-
-1. **Structure test**: Is this genuinely about code structure? Or is it a bug, convention, or documentation issue disguised as refactoring?
-2. **Impact test**: Would a developer actually struggle with this structure? Or is it just "could be slightly different"?
-3. **Scope check**: Is the issue IN the target code, or in how other code uses it?
-
-**Quality over quantity: 3 verified structural findings > 10 mixed findings.**
-
-## Constraints
-
-- Analysis only. Do NOT modify any files.
-- Do NOT provide corrected code blocks. Describe issues and suggestions in words only.
-- Only report structural issues with real evidence from the code.
-- Focus on substance: structural problems that genuinely make the code harder to understand or modify.
-
-## Output Format
-
-Use this exact format for every finding:
-
-### [HIGH|MEDIUM|LOW] title
-
-- **File**: path/to/file.ts:42
-- **Evidence**: what you observed (include code snippet)
-- **Issue**: what the structural problem is
-- **Suggestion**: how to improve it (in words, not code)
-
-Impact levels:
-- HIGH: Major structural problem. Significantly harder to understand or modify safely.
-- MEDIUM: Notable structural concern. Unnecessary complexity or meaningful duplication.
-- LOW: Improvement opportunity. Cleaner structure exists but current code is workable.
-
-Start your report with:
-
-## Code Simplification Results
-
-### Summary
-- Files reviewed: N
-- Findings: X HIGH, Y MEDIUM, Z LOW
-
-### Findings
-[findings here]
-```

package/claude/skills/sd-review/structure-analyzer-prompt.md

@@ -1,97 +0,0 @@
-# Structure Analyzer Prompt
-
-Template for `Agent(general-purpose)`. Fill in `[TARGET_PATH]`.
-
-```
-You are analyzing code for structural organization and responsibility separation.
-Your question: "Is the code organized in a way that makes responsibilities clear and changes localized?"
-
-## Target
-
-Analyze ALL source files at [TARGET_PATH].
-
-## Step 1: List all source files
-
-Use Glob to list all .ts/.tsx files under the target path (exclude node_modules, dist).
-This is your analysis scope — every file in this list must be examined.
-
-## Step 2: Understand the architecture
-
-Read the following reference files for project conventions:
-- `CLAUDE.md` — project overview and conventions
-- `.claude/rules/sd-refs-linker.md` — reference guide linking to detailed docs per topic (read relevant refs based on the target code)
-
-Then:
-- Read index.ts to map the module structure and public exports
-- Identify module boundaries: what each module/file owns
-- Map abstraction levels: which code is high-level vs low-level
-- Identify responsibility groupings: which functions/classes belong together
-
-## Step 3: Find structural improvement opportunities
-
-Look for:
-- Responsibility mixing: a single module handling concerns that should be separate
-- Abstraction level mismatch: high-level orchestration mixed with low-level implementation details in the same function/module
-- Module organization: related functionality scattered across unrelated files, or unrelated functionality grouped together
-- Leaking abstractions: internal implementation details exposed through public API that force consumers to know about internals
-- Coupling hotspots: modules where a change would cascade to many other files
-
-## CRITICAL — Scope boundaries
-
-Do NOT report ANY of the following. These are OUT OF SCOPE:
-- Bugs, security, logic errors, race conditions → that's code review
-- Naming consistency, API design, type quality → that's API review
-- Code complexity, duplication within a single function → that's code simplification
-- Circular dependencies, wrong dependency direction, boundary violations → that's code review (architectural defects)
-- Style preferences, comment style, import ordering
-- Dependencies that are clearly intentional and well-established patterns in the codebase
-- Issues in code OUTSIDE the target path
-
-**Key distinction:** Architectural DEFECTS (circular deps, boundary violations) are for code review. Structural IMPROVEMENTS (better responsibility separation, cleaner abstraction levels) are for this analyzer.
-
-## Step 4: Self-verify before reporting
-
-Before including ANY finding:
-
-1. **Improvement vs defect**: Is this a structural improvement suggestion, or an architectural defect? If defect → not in scope.
-2. **Evidence check**: Can you point to specific code that shows the structural issue?
-3. **Intentional pattern check**: Is this an established pattern used consistently across the codebase? If yes → by-design, drop it.
-4. **Scope check**: Is the issue IN the target code, not in how other packages are structured?
-
-**Quality over quantity: 3 verified structural findings > 10 maybe-findings.**
-
-## Constraints
-
-- Analysis only. Do NOT modify any files.
-- Do NOT provide corrected code blocks. Describe improvements in words only.
-- Only report issues with concrete evidence (specific code references).
-- If the structure is consistent across the codebase, treat it as intentional.
-
-## Output Format
-
-Use this exact format for every finding:
-
-### [HIGH|MEDIUM|LOW] title
-
-- **File**: path/to/file.ts:42
-- **Evidence**: what you observed (include code snippet)
-- **Issue**: what the structural concern is
-- **Suggestion**: how to improve the structure (in words, not code)
-
-Impact levels:
-- HIGH: Major structural issue. Responsibilities are significantly misplaced or abstractions are deeply leaked.
-- MEDIUM: Notable structural concern. Better organization would meaningfully improve maintainability.
-- LOW: Improvement opportunity. Cleaner structure exists but current organization is workable.
-
-Start your report with:
-
-## Structure Analysis Results
-
-### Summary
-- Files reviewed: N
-- Module structure: brief description
-- Findings: X HIGH, Y MEDIUM, Z LOW
-
-### Findings
-[findings here]
-```

package/claude/skills/sd-worktree/sd-worktree.mjs

@@ -1,152 +0,0 @@
-#!/usr/bin/env node
-import { execSync } from "node:child_process";
-import { existsSync, rmSync } from "node:fs";
-import { resolve, sep } from "node:path";
-
-const [cmd, ...args] = process.argv.slice(2);
-
-function run(command, opts) {
-  execSync(command, { encoding: "utf-8", stdio: "inherit", ...opts });
-}
-
-function getOutput(command) {
-  return execSync(command, { encoding: "utf-8" }).trim();
-}
-
-// Main working tree path (accurate even when run inside a worktree)
-const mainWorktree = getOutput("git worktree list --porcelain")
-  .split("\n")[0]
-  .replace("worktree ", "");
-
-function detectPackageManager() {
-  if (existsSync(resolve(mainWorktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(resolve(mainWorktree, "yarn.lock"))) return "yarn";
-  if (existsSync(resolve(mainWorktree, "package-lock.json"))) return "npm";
-  if (
-    existsSync(resolve(mainWorktree, "bun.lockb")) ||
-    existsSync(resolve(mainWorktree, "bun.lock"))
-  )
-    return "bun";
-  return "npm";
-}
-
-function detectWorktreeName() {
-  const cwd = process.cwd();
-  const worktreesDir = resolve(mainWorktree, ".worktrees");
-  if (cwd.startsWith(worktreesDir + sep)) {
-    return cwd.slice(worktreesDir.length + 1).split(sep)[0];
-  }
-  return undefined;
-}
-
-function getMainBranch() {
-  return getOutput(`git -C "${mainWorktree}" rev-parse --abbrev-ref HEAD`);
-}
-
-switch (cmd) {
-  case "add": {
-    const name = args[0];
-    if (!name) {
-      console.error("Usage: sd-worktree.mjs add <kebab-case-name>");
-      process.exit(1);
-    }
-    const worktreePath = resolve(mainWorktree, ".worktrees", name);
-    if (existsSync(worktreePath)) {
-      console.error(`Already exists: ${worktreePath}`);
-      process.exit(1);
-    }
-    const branch = getMainBranch();
-    console.log(`Creating worktree: .worktrees/${name} (from ${branch})`);
-    run(`git worktree add "${worktreePath}" -b "${name}"`);
-    const pm = detectPackageManager();
-    console.log(`Installing dependencies (${pm})...`);
-    run(`${pm} install`, { cwd: worktreePath });
-    console.log(`\nReady: ${worktreePath}`);
-    break;
-  }
-
-  case "merge": {
-    const name = args[0] ?? detectWorktreeName();
-    if (!name) {
-      console.error("Usage: sd-worktree.mjs merge [name]  (or run inside .worktrees/<name>)");
-      process.exit(1);
-    }
-    // Check for uncommitted changes
-    const worktreePath_m = resolve(mainWorktree, ".worktrees", name);
-    if (existsSync(worktreePath_m)) {
-      const status = getOutput(`git -C "${worktreePath_m}" status --porcelain`);
-      if (status) {
-        console.error(`Error: worktree '${name}' has uncommitted changes:\n${status}`);
-        console.error("Commit or stash changes before merging.");
-        process.exit(1);
-      }
-    }
-    const branch = getMainBranch();
-    console.log(`Merging '${name}' into '${branch}'...`);
-    run(`git merge "${name}" --no-ff`, { cwd: mainWorktree });
-    console.log(`\nMerged '${name}' into '${branch}'.`);
-    break;
-  }
-
-  case "rebase": {
-    const name = args[0] ?? detectWorktreeName();
-    if (!name) {
-      console.error("Usage: sd-worktree.mjs rebase [name]  (or run inside .worktrees/<name>)");
-      process.exit(1);
-    }
-    const worktreePath_r = resolve(mainWorktree, ".worktrees", name);
-    if (!existsSync(worktreePath_r)) {
-      console.error(`Error: worktree '${name}' does not exist.`);
-      process.exit(1);
-    }
-    // Check for uncommitted changes
-    const statusR = getOutput(`git -C "${worktreePath_r}" status --porcelain`);
-    if (statusR) {
-      console.error(`Error: worktree '${name}' has uncommitted changes:\n${statusR}`);
-      console.error("Commit or stash changes before rebasing.");
-      process.exit(1);
-    }
-    const branchR = getMainBranch();
-    console.log(`Rebasing '${name}' onto '${branchR}'...`);
-    run(`git rebase "${branchR}"`, { cwd: worktreePath_r });
-    console.log(`\nRebased '${name}' onto '${branchR}'.`);
-    break;
-  }
-
-  case "clean": {
-    const name = args[0] ?? detectWorktreeName();
-    if (!name) {
-      console.error("Usage: sd-worktree.mjs clean [name]  (or run inside .worktrees/<name>)");
-      process.exit(1);
-    }
-    // Block execution from inside the worktree
-    const worktreePath = resolve(mainWorktree, ".worktrees", name);
-    const cwd = process.cwd();
-    if (cwd === worktreePath || cwd.startsWith(worktreePath + "/")) {
-      console.error(`Error: Cannot clean '${name}' from inside its worktree.`);
-      console.error(
-        `Run: cd "${mainWorktree}" && node .claude/skills/sd-worktree/sd-worktree.mjs clean ${name}`,
-      );
-      process.exit(1);
-    }
-    if (existsSync(worktreePath)) {
-      console.log(`Removing worktree: .worktrees/${name}`);
-      try {
-        run(`git worktree remove --force "${worktreePath}"`, { cwd: mainWorktree });
-      } catch {
-        // Manual cleanup when git worktree remove fails (e.g., due to node_modules)
-        console.log("git worktree remove failed, cleaning up manually...");
-        rmSync(worktreePath, { recursive: true, force: true });
-        run("git worktree prune", { cwd: mainWorktree });
-      }
-    }
-    console.log(`Deleting branch: ${name}`);
-    run(`git branch -d "${name}"`, { cwd: mainWorktree });
-    console.log(`\nCleaned up '${name}'.`);
-    break;
-  }
-
-  default:
-    console.error("Usage: sd-worktree.mjs <add|merge|rebase|clean> [name]");
-    process.exit(1);
-}