shokunin 1.2.0 → 1.3.0

package/README.md

@@ -57,11 +57,15 @@ Every feature starts with a clean workspace.
 ```
 
 This creates:
-- A git worktree at `../PROJ-123-add-user-authentication/`
+- A git worktree at `.worktrees/PROJ-123-add-user-authentication/`
 - A branch `PROJ-123/add-user-authentication`
 - A plan scaffold at `.claude/plans/PROJ-123.md`
 
-Open a new terminal, `cd` into the worktree, and start Claude Code.
+Open a new terminal, `cd` into the worktree, and start Claude Code:
+
+```bash
+cd .worktrees/PROJ-123-add-user-authentication && claude
+```
 
 ### 2. `/shokunin:plan` — Measure Twice, Cut Once
 
@@ -180,10 +184,13 @@ with session management and token refresh.
 Shokunin uses git worktrees to support working on multiple features simultaneously.
 
 ```
-~/src/myproject/                              main repo
-  +-- ../PROJ-123-add-auth/                   worktree (Claude session B)
-  +-- ../PROJ-456-fix-dashboard/              worktree (Claude session C)
-  +-- ../PROJ-789-api-refactor/               worktree (Claude session D)
+~/src/myproject/
+  .worktrees/                                 gitignored
+    PROJ-123-add-auth/                        worktree (Claude session B)
+    PROJ-456-fix-dashboard/                   worktree (Claude session C)
+    PROJ-789-api-refactor/                    worktree (Claude session D)
+  src/
+  package.json
 ```
 
 Each worktree is a separate directory with its own branch and Claude Code session. Run `/shokunin:wip` from any session to see all features in flight:
@@ -191,11 +198,11 @@ Each worktree is a separate directory with its own branch and Claude Code sessio
 ```
 Shokunin — Work in Progress
 
-| Worktree                | Branch                   | Ticket   | Status      | Progress  |
-|-------------------------|--------------------------|----------|-------------|-----------|
-| ../PROJ-123-add-auth    | PROJ-123/add-auth        | PROJ-123 | in-progress | 4/7 tasks |
-| ../PROJ-456-fix-dash    | PROJ-456/fix-dash        | PROJ-456 | review      | 5/5 tasks |
-| . (main)                | main                     | —        | —           | —         |
+| Worktree                          | Branch                   | Ticket   | Status      | Progress  |
+|-----------------------------------|--------------------------|----------|-------------|-----------|
+| .worktrees/PROJ-123-add-auth      | PROJ-123/add-auth        | PROJ-123 | in-progress | 4/7 tasks |
+| .worktrees/PROJ-456-fix-dash      | PROJ-456/fix-dash        | PROJ-456 | review      | 5/5 tasks |
+| . (main)                          | main                     | —        | —           | —         |
 ```
 
 ## Git Strategy
@@ -204,7 +211,7 @@ Shokunin — Work in Progress
 - **During development:** WIP commits (`wip: <task name>`) — safe, cheap, squashed later
 - **At ship time:** All commits squashed into one: `PROJ-123: feat: description`
 - **PRs:** Created via `gh pr create`, merged manually on GitHub
-- **Cleanup:** `git worktree remove` after merge
+- **Cleanup:** `git worktree remove .worktrees/<ticket>-<slug>` after merge
 
 ## Quick Flow
 

package/bin/install.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
+const { execSync } = require('child_process');
 
 const SKILLS = ['start', 'plan', 'build', 'review', 'ship', 'wip', 'docs'];
 const AGENTS = ['code-reviewer'];
@@ -50,6 +51,7 @@ async function promptUser(question) {
 async function main() {
   const args = process.argv.slice(2);
   const force = args.includes('--force');
+  const noCommit = args.includes('--no-commit');
 
   const projectRoot = findProjectRoot(process.cwd());
   const packageRoot = path.resolve(__dirname, '..');
@@ -133,12 +135,49 @@ async function main() {
     }
   }
 
+  // Add .worktrees/ to .gitignore
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+  let gitignoreUpdated = false;
+  const worktreeEntry = '.worktrees/';
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    if (!content.includes(worktreeEntry)) {
+      fs.appendFileSync(gitignorePath, `\n# Shokunin worktrees\n${worktreeEntry}\n`);
+      gitignoreUpdated = true;
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, `# Shokunin worktrees\n${worktreeEntry}\n`);
+    gitignoreUpdated = true;
+  }
+
+  // Auto-commit skills to git so worktrees inherit them
+  const hasChanges = installed > 0 || updated > 0;
+  let committed = false;
+
+  if ((hasChanges || gitignoreUpdated) && !noCommit) {
+    const isGitRepo = fs.existsSync(path.join(projectRoot, '.git'));
+    if (isGitRepo) {
+      try {
+        execSync('git add .claude/skills/ .claude/agents/', { cwd: projectRoot, stdio: 'pipe' });
+        if (gitignoreUpdated) {
+          execSync('git add .gitignore', { cwd: projectRoot, stdio: 'pipe' });
+        }
+        execSync('git commit -m "chore: install shokunin engineering process skills"', { cwd: projectRoot, stdio: 'pipe' });
+        committed = true;
+      } catch {
+        // Commit may fail if nothing staged (already tracked) or no git user configured
+        committed = false;
+      }
+    }
+  }
+
   // Summary
   console.log('');
   console.log('  Done!');
   if (installed > 0) console.log(`    Installed: ${installed}`);
   if (updated > 0) console.log(`    Updated:   ${updated}`);
   if (skipped > 0) console.log(`    Unchanged: ${skipped}`);
+  if (committed) console.log('    Committed to git (skills available in worktrees)');
   console.log('');
   console.log('  Skills installed:');
   for (const skill of SKILLS) {
@@ -152,8 +191,14 @@ async function main() {
   console.log('    /shokunin:review                           # Code review');
   console.log('    /shokunin:ship                             # Squash, PR, ship it');
   console.log('');
+  if (!committed && hasChanges) {
+    console.log('  [!] Skills were not committed to git.');
+    console.log('      Run: git add .claude/skills/ .claude/agents/ && git commit');
+    console.log('      (Skills must be committed for worktrees to inherit them)');
+    console.log('');
+  }
   console.log('  Prerequisites:');
-  console.log('    - gh CLI installed and authenticated (for /ship)');
+  console.log('    - gh CLI installed and authenticated (for /shokunin:ship)');
   console.log('    - Add Bash(gh *) to ~/.claude/settings.json allow list');
   console.log('');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shokunin",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Lightweight engineering process skills for Claude Code — craftsmanship in AI-assisted development",
   "bin": {
     "shokunin": "bin/install.js"

package/skills/ship/SKILL.md

@@ -115,7 +115,7 @@ After the PR is created, tell the user:
 PR created: <URL>
 
 After the PR is merged, clean up the worktree:
-  git worktree remove <worktree-dir>
+  git worktree remove .worktrees/<ticket>-<slug>
 ```
 
 ## Important

package/skills/start/SKILL.md

@@ -23,22 +23,60 @@ You are the initialisation phase of the shokunin engineering process. Set up a c
 
 - **Branch name:** `<ticket>/<slugified-description>` — lowercase, hyphens, no special chars
   - Example: `PROJ-123/add-user-authentication`
-- **Worktree directory:** `../<ticket>-<slug>`
-  - Example: `../PROJ-123-add-user-authentication`
+- **Worktree directory:** `.worktrees/<ticket>-<slug>`
+  - Example: `.worktrees/PROJ-123-add-user-authentication`
 
-### 3. Create Worktree
+### 3. Ensure .worktrees/ is Gitignored
+
+Check if `.worktrees/` is in `.gitignore`. If not, add it:
+
+```bash
+grep -q '^\.worktrees/' .gitignore 2>/dev/null || echo '.worktrees/' >> .gitignore
+```
+
+Create the `.worktrees/` directory if it doesn't exist:
 
 ```bash
-git worktree add -b <branch-name> <worktree-dir> main
+mkdir -p .worktrees
+```
+
+### 4. Create Worktree
+
+```bash
+git worktree add -b <branch-name> .worktrees/<ticket>-<slug> main
 ```
 
 If the branch already exists, ask the user if they want to resume work on it or start fresh.
 
-### 4. Create Plan Scaffold
+### 5. Ensure Skills Exist in Worktree
+
+Check if `.claude/skills/` exists in the new worktree. If it doesn't (e.g. skills weren't committed to main), copy them from the source repo:
+
+```bash
+# Check if skills exist in the worktree
+ls <worktree-dir>/.claude/skills/plan/SKILL.md
+```
+
+If missing, copy the entire `.claude/skills/` and `.claude/agents/` directories from the current repo into the worktree:
+
+```bash
+cp -r .claude/skills <worktree-dir>/.claude/skills
+cp -r .claude/agents <worktree-dir>/.claude/agents
+```
+
+Then commit them on the feature branch so they persist:
+
+```bash
+cd <worktree-dir>
+git add .claude/skills/ .claude/agents/
+git commit -m "chore: add shokunin skills to feature branch"
+```
+
+### 7. Create Plan Scaffold
 
 Create the directory `.claude/plans/` in the worktree if it doesn't exist.
 
-Write `.claude/plans/<ticket>.md` with this scaffold:
+Write `.claude/plans/<ticket>.md` in the worktree with this scaffold:
 
 ```markdown
 # Feature: <feature description>
@@ -61,7 +99,7 @@ Write `.claude/plans/<ticket>.md` with this scaffold:
 <To be captured during /plan>
 ```
 
-### 5. Print Next Steps
+### 8. Print Next Steps
 
 Tell the user: