claude-cli-advanced-starter-pack 1.0.11 → 1.0.13

package/templates/commands/create-task-list.template.md

@@ -50,15 +50,95 @@ These rules are loaded automatically and apply to ALL task lists created by this
 
 ## EXECUTION FLOW
 
-### Step 0: Load Persistent Rules
+### Step 0: Check Testing Configuration (Graceful Degradation)
 
-**FIRST ACTION**: Read `.claude/task-lists/TESTING_RULES.md` to load testing and deployment rules.
+**FIRST ACTION**: Check what testing configuration is available and display status.
+
+**Configuration Check**:
+
+1. **Read tech-stack.json** (`.claude/tech-stack.json` or `tech-stack.json`)
+2. **Check testing section** for:
+   - `testing.e2e.framework` - E2E framework (playwright, cypress, etc.)
+   - `testing.selectors.*` - Login form selectors
+   - `testing.credentials.*` - Environment variable names
+   - `testing.environment.*` - Base URL and setup
+
+3. **Display Configuration Status**:
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  📋 Testing Configuration Status                               ║
+╠═══════════════════════════════════════════════════════════════╣
+{{#if testing.e2e.framework}}
+║  ✅ E2E Framework: {{testing.e2e.framework}}                   ║
+{{else}}
+║  ⚠️  E2E Framework: Not configured                             ║
+{{/if}}
+{{#if testing.selectors.username}}
+║  ✅ Login Selectors: Configured                                ║
+{{else}}
+║  ⚠️  Login Selectors: Not configured                           ║
+{{/if}}
+{{#if testing.credentials.usernameEnvVar}}
+║  ✅ Credentials: Using env vars                                ║
+{{else}}
+║  ⚠️  Credentials: Not configured                               ║
+{{/if}}
+{{#if testing.environment.baseUrl}}
+║  ✅ Test URL: {{testing.environment.baseUrl}}                  ║
+{{else}}
+║  ⚠️  Test URL: Not configured                                  ║
+{{/if}}
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+**Graceful Degradation Rules**:
+
+| Config Status | Behavior |
+|---------------|----------|
+| **Fully configured** | Include all testing tasks (login, verification, E2E) |
+| **Partially configured** | Include available tests, warn about missing pieces |
+| **Not configured** | Skip testing tasks, show setup reminder at end |
+
+**If testing is NOT configured**, display this reminder and continue:
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  ℹ️  Testing not configured - skipping E2E verification        ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  To enable automated testing, run:                            ║
+║                                                               ║
+║    ccasp test-setup                                           ║
+║                                                               ║
+║  Or configure manually in tech-stack.json under "testing"     ║
+║                                                               ║
+║  Task list will be created WITHOUT testing tasks.             ║
+║  You can still test manually after implementation.            ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+**Store configuration status** for use in later steps:
+- `TESTING_CONFIGURED`: true/false
+- `E2E_ENABLED`: true if framework is set and not 'none'
+- `SELECTORS_AVAILABLE`: true if login selectors exist
+
+---
+
+### Step 0b: Load Persistent Rules (if configured)
+
+{{#if testing.e2e.framework}}
+**Read `.claude/task-lists/TESTING_RULES.md`** to load testing and deployment rules.
 
 These rules govern:
 - Which URLs to use ({{devEnvironment.tunnel.service}} vs {{urls.production.frontend}})
 - Login credentials
 - Deployment workflow (delete {{frontend.distDir}}, rebuild, verify SHA)
 - Task completion workflow (curl → {{testing.e2e.framework}} → commit)
+{{else}}
+**Skip loading TESTING_RULES.md** - testing not configured.
+{{/if}}
 
 ---
 
@@ -164,7 +244,8 @@ Based on my exploration, here's what I found:
 
 **MANDATORY QUESTIONS** (use AskUserQuestion with multiple questions):
 
-**Question 1: Testing Approach**
+{{#if testing.e2e.framework}}
+**Question 1: Testing Approach** (only if E2E_ENABLED)
 ```
 header: "Testing"
 question: "Do you want to use 'Ralph Wiggum Loop' style testing? (Continuous test-fix cycle until all tests pass)"
@@ -176,8 +257,23 @@ options:
   - label: "Minimal Testing"
     description: "Only test at the end of all tasks"
 ```
+{{else}}
+**Question 1: Testing Approach** (testing not configured - simplified options)
+```
+header: "Testing"
+question: "Testing is not configured. How would you like to verify your changes?"
+options:
+  - label: "Manual verification only"
+    description: "I'll test the changes manually - no automated tests"
+  - label: "Setup testing first"
+    description: "I want to configure automated testing before proceeding (run: ccasp test-setup)"
+```
 
-**Question 2: {{testing.e2e.framework}} Environment**
+**Note**: If user selects "Setup testing first", provide instructions to run `ccasp test-setup` and restart the task list creation.
+{{/if}}
+
+{{#if testing.e2e.framework}}
+**Question 2: {{testing.e2e.framework}} Environment** (only if E2E_ENABLED)
 ```
 header: "{{testing.e2e.framework}}"
 question: "Where should {{testing.e2e.framework}} E2E tests run?"
@@ -189,6 +285,9 @@ options:
   - label: "No {{testing.e2e.framework}}"
     description: "Skip E2E tests, use curl/unit tests only"
 ```
+{{else}}
+**Question 2: SKIP** (E2E not configured - skip this question)
+{{/if}}
 
 **Question 3: GitHub Integration**
 ```
@@ -212,14 +311,30 @@ options:
     description: "I'll describe what to change"
 ```
 
+**Question 5: Task Execution Strategy**
+```
+header: "Execution"
+question: "How would you like to execute tasks?"
+options:
+  - label: "Sequential - One at a time (Recommended)"
+    description: "Complete each task fully, commit, then move to next. More control, easier rollback"
+  - label: "Grouped - Related tasks together"
+    description: "Group related tasks, commit after each group. Balanced approach"
+  - label: "All at once"
+    description: "Execute all tasks, single final commit. Fastest but harder to debug"
+```
+
+**Store the user's execution preference** for use in Step 8.
+
 ---
 
 ### Step 5: Create Task List
 
 Use **TaskCreate** to build the task list with Claude's native system.
 
-**Task List Structure**:
+**Task List Structure** (adapts based on TESTING_CONFIGURED status):
 
+{{#if testing.e2e.framework}}
 ```
 Task 0: "Review Testing Rules" (DO NOT MARK COMPLETE)
   description: "Read .claude/task-lists/TESTING_RULES.md before starting. These rules apply to all tasks."
@@ -244,7 +359,7 @@ Task 2: "[First actual task]"
   description: "[What needs to be done]"
   activeForm: "[Present participle form]"
 
-Task 2: "[Second task]"
+Task 3: "[Second task]"
   ...
 
 Task N-1: "Run final verification tests"
@@ -255,11 +370,41 @@ Task N: "Commit all changes"
   description: "Create a git commit with all changes from this session"
   activeForm: "Committing changes"
 ```
+{{else}}
+```
+Task 0: "Context Reference" (DO NOT MARK COMPLETE)
+  description: "Testing not configured. To enable: run 'ccasp test-setup'. Tasks below will NOT include automated testing."
+  activeForm: "Maintaining context"
+
+Task 1: "[First actual task]"
+  description: "[What needs to be done]"
+  activeForm: "[Present participle form]"
+
+Task 2: "[Second task]"
+  ...
+
+Task N-1: "Manual verification"
+  description: "Manually test the changes in your browser/application to verify everything works"
+  activeForm: "Manually verifying changes"
+
+Task N: "Commit all changes"
+  description: "Create a git commit with all changes from this session"
+  activeForm: "Committing changes"
+```
+
+**Note**: Since E2E testing is not configured, the task list excludes:
+- Login via Playwright/Puppeteer task
+- Automated E2E verification tests
+
+The user should manually verify changes work before committing.
+{{/if}}
 
 **IMPORTANT**:
 - Task 0 with persistent instructions should NEVER be marked complete
 - Each task should be atomic and independently verifiable
+{{#if testing.e2e.framework}}
 - Include curl testing tasks BEFORE {{testing.e2e.framework}} tasks when debugging
+{{/if}}
 
 ---
 
@@ -267,6 +412,49 @@ Task N: "Commit all changes"
 
 If user selected GitHub integration:
 
+#### Step 6a: Preview Issue Before Creation
+
+**Present issue preview to user** before creating:
+
+```markdown
+## GitHub Issue Preview
+
+**Title:** [Generated from user prompt]
+**Priority:** P2-Medium (or determined from analysis)
+**Labels:** [Determined from exploration - frontend, backend, feature, bug, etc.]
+**Stack:** [Frontend only | Backend only | Both]
+
+**Description Preview:**
+> [First 200 characters of the analysis from Step 3...]
+
+**Task Checklist:**
+- [ ] Task 1: [First task]
+- [ ] Task 2: [Second task]
+- [ ] ...
+```
+
+**Ask for confirmation using AskUserQuestion:**
+```
+header: "Create GitHub Issue?"
+question: "Ready to create this GitHub issue? Review the preview above."
+options:
+  - label: "Yes - Create Issue"
+    description: "Create the issue and enable auto-progress tracking"
+  - label: "Modify Details"
+    description: "I want to change the title, priority, or labels"
+  - label: "Skip GitHub"
+    description: "Don't create issue, use local TodoWrite only"
+```
+
+**Handle user response:**
+- **"Yes - Create Issue"**: Proceed to create the issue (Step 6b)
+- **"Modify Details"**: Ask which fields to change, then show preview again
+- **"Skip GitHub"**: Skip to Step 7, note that GitHub tracking is disabled
+
+---
+
+#### Step 6b: Create the Issue
+
 1. **Create comprehensive issue** using `/github-create-task`:
    ```bash
    /github-create-task --batch-mode
@@ -311,6 +499,43 @@ If user selected GitHub integration:
      - Adds a progress comment if significant milestone
    - See `.claude/hooks/tools/github-progress-hook.js`
 
+#### Step 6c: Post-Creation Confirmation
+
+After the issue is created, **display confirmation and ask how to proceed**:
+
+```markdown
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ GitHub Issue Created Successfully                         ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Issue: #[ISSUE_NUMBER]                                       ║
+║  URL: https://github.com/[owner]/[repo]/issues/[number]       ║
+║                                                               ║
+║  Auto-progress tracking enabled:                              ║
+║  • Tasks will auto-update issue as they complete              ║
+║  • Checkboxes will be checked off automatically               ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+**Ask user how to proceed using AskUserQuestion:**
+```
+header: "Issue Created"
+question: "GitHub issue #[NUMBER] created. What would you like to do?"
+options:
+  - label: "Continue to Task Execution"
+    description: "Proceed with creating and executing the task list"
+  - label: "View Issue in Browser"
+    description: "Open the issue, then come back to continue"
+  - label: "Exit for Now"
+    description: "Save session state, I'll continue later"
+```
+
+**Handle user response:**
+- **"Continue to Task Execution"**: Proceed to Step 7
+- **"View Issue in Browser"**: Provide clickable link, wait for user to return, then proceed
+- **"Exit for Now"**: Save session state to `.claude/task-lists/session-{timestamp}.json` and exit gracefully
+
 ---
 
 ### Step 7: Configure Ralph Loop (If Selected)
@@ -330,9 +555,11 @@ const config = {
 
 ---
 
-### Step 8: Compact Session & Begin
+### Step 8: Final Review & Begin Execution
+
+#### Step 8a: Display Task Summary
 
-1. **Display task summary**:
+1. **Display comprehensive task summary**:
    ```
    ## Task List Created
 
@@ -343,21 +570,109 @@ const config = {
    | 2 | [Task 2 subject] | pending |
    ...
 
-   **Testing Mode:** [Ralph Loop / Manual / Minimal]
-   **Environment:** [{{devEnvironment.tunnel.service}} / {{urls.production.frontend}}]
-   **GitHub Issue:** [#123 (if created) | Not tracked]
-
-   Ready to begin. Starting with Task 1...
+   **Configuration:**
+{{#if testing.e2e.framework}}
+   - Testing Mode: [Ralph Loop / Manual / Minimal]
+   - E2E Framework: {{testing.e2e.framework}}
+   - Environment: [{{devEnvironment.tunnel.service}} / {{urls.production.frontend}}]
+{{else}}
+   - Testing: Not configured (manual verification only)
+   - To enable: run `ccasp test-setup`
+{{/if}}
+   - Execution Strategy: [Sequential / Grouped / All at once]
+   - GitHub Issue: [#123 (if created) | Not tracked]
    ```
 
+#### Step 8b: Final Confirmation Before Execution
+
+**Ask user to confirm before starting using AskUserQuestion:**
+```
+header: "Ready to Begin?"
+question: "Review the task list above. How would you like to proceed?"
+options:
+  - label: "Start Task 1 Now"
+    description: "Begin executing the first task immediately"
+  - label: "Start from Different Task"
+    description: "Skip to a specific task number"
+  - label: "Modify Task List"
+    description: "Add, remove, or edit tasks before starting"
+  - label: "Save & Exit"
+    description: "Save the task list for later, exit now"
+```
+
+**Handle user response:**
+- **"Start Task 1 Now"**: Proceed to Step 8c
+- **"Start from Different Task"**: Ask which task number, validate it exists, start there
+- **"Modify Task List"**: Allow user to describe changes, update TaskList, show summary again
+- **"Save & Exit"**: Save full session state to `.claude/task-lists/session-{timestamp}.json`, display resume instructions, exit
+
+#### Step 8c: Begin Execution
+
 2. **Compact context** (use /compact if token usage is high)
 
-3. **Begin Task 1**:
+3. **Execute based on user's chosen strategy** (from Step 4, Question 5):
+
+   **Sequential Execution (One at a time):**
    - Use `TaskUpdate` to set Task 1 to `in_progress`
-   - Execute the task
+   - Execute the task fully
    - Use `TaskUpdate` to set Task 1 to `completed`
-   - Commit changes
-   - Move to Task 2
+   - **Commit changes for this task**
+   - Ask: "Task 1 complete. Ready for Task 2?" (brief confirmation)
+   - Repeat for each task
+
+   **Grouped Execution:**
+   - Identify related task groups (e.g., all frontend tasks, all backend tasks)
+   - Execute all tasks in a group
+   - Commit after completing each group
+   - Brief status update between groups
+
+   **All at Once Execution:**
+   - Execute all tasks without intermediate commits
+   - Single comprehensive commit at the end
+   - Higher risk but faster for simple changes
+
+---
+
+### Step 9: Post-Execution Summary
+
+After all tasks are complete, display a summary:
+
+{{#if testing.e2e.framework}}
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ All Tasks Completed                                        ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Tasks completed: [N]                                         ║
+║  E2E tests: [Passed/Failed]                                   ║
+║  Commits made: [M]                                            ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+{{else}}
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ All Tasks Completed                                        ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Tasks completed: [N]                                         ║
+║  Commits made: [M]                                            ║
+║                                                               ║
+║  ℹ️  Testing was skipped (not configured)                      ║
+║                                                               ║
+║  To enable automated E2E testing for future tasks:            ║
+║                                                               ║
+║    ccasp test-setup                                           ║
+║                                                               ║
+║  This will configure:                                         ║
+║  • Playwright/Cypress/Puppeteer integration                   ║
+║  • Login selectors for authenticated testing                  ║
+║  • Test environment URLs                                      ║
+║  • Ralph Loop continuous testing                              ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+{{/if}}
 
 ---
 

package/templates/commands/project-impl.template.md

@@ -305,6 +305,19 @@ Questions:
 After completing any option, ask the user:
 - "Would you like to perform another action? (1-4, B to go back, Q to quit)"
 
+## Mark Setup Complete
+
+**IMPORTANT:** After the user successfully completes ANY option (1-4), update the state file to mark setup as complete:
+
+```bash
+# Read current state, add projectImplCompleted: true, write back
+```
+
+Use the Edit tool to update `.claude/config/ccasp-state.json`:
+- Set `"projectImplCompleted": true`
+
+This removes the "Run /project-impl" recommendation banner from `/menu`.
+
 ## Terminal Alternative
 
 These operations can also be run from the terminal:

package/templates/commands/update-smart.template.md

@@ -0,0 +1,111 @@
+# Smart Update Manager
+
+Explore and manage updates for your customized CCASP assets with intelligent merge suggestions.
+
+## Overview
+
+This command helps you safely update customized commands, skills, agents, and hooks while preserving your modifications. It detects which assets you've customized and used, then provides merge exploration with Claude's analysis.
+
+## When to Use
+
+- After running `npm update -g claude-cli-advanced-starter-pack`
+- When `/menu` shows an update is available with customized assets
+- To review what changes an update would bring before applying
+
+## Execution Flow
+
+### Step 1: Detect Customized Assets
+
+Read `.claude/config/usage-tracking.json` to identify:
+- Assets you've used (commands, skills, agents, hooks)
+- Assets marked as customized (modified from template)
+- Usage frequency and last-used dates
+
+### Step 2: Compare with Templates
+
+For each customized asset:
+1. Load your local version from `.claude/`
+2. Load the template version from the CCASP package
+3. Generate a diff comparison
+4. Analyze change significance (low/medium/high)
+
+### Step 3: Present Merge Options
+
+For each asset with differences, offer:
+
+| Option | Description |
+|--------|-------------|
+| **Explore** | Show detailed analysis with Claude's explanation of changes |
+| **Replace** | Use the new template version (backup created) |
+| **Skip** | Keep your customized version |
+| **Show Diff** | View raw line-by-line differences |
+
+### Step 4: Apply Decisions
+
+- Backup files go to `.claude/backups/` with timestamps
+- Update `.claude/config/usage-tracking.json` to reflect changes
+- Generate summary report of actions taken
+
+## Usage Examples
+
+### Check for updates
+```
+/update-smart
+```
+
+### Force re-check (bypass cache)
+```
+/update-smart --force
+```
+
+### Only show customized assets (no update)
+```
+/update-smart --list
+```
+
+## Output
+
+### Asset Summary Table
+```
+┌────────────────────────────────────────────────────────────────┐
+│  Customized Assets Detected                                    │
+├────────────────────────────────────────────────────────────────┤
+│  Commands (3)                                                  │
+│    • /create-task-list  - 🟡 Medium changes - Used 12 times   │
+│    • /github-update     - 🟢 Minor changes - Used 5 times     │
+│    • /e2e-test          - 🔴 Major changes - Used 8 times     │
+├────────────────────────────────────────────────────────────────┤
+│  Skills (1)                                                    │
+│    • dms                - 🟡 Medium changes - Used 3 times    │
+└────────────────────────────────────────────────────────────────┘
+```
+
+### Change Significance Legend
+- 🟢 **Low**: Comment changes, formatting, minor tweaks
+- 🟡 **Medium**: Configuration changes, new options
+- 🔴 **High**: Structural changes, new features, breaking changes
+
+## Related Commands
+
+- `/update-check` - Check for CCASP updates
+- `/menu` - View update status in main menu
+- `/ccasp-setup` - Re-run setup wizard
+
+## File Locations
+
+| File | Purpose |
+|------|---------|
+| `.claude/config/usage-tracking.json` | Asset usage data |
+| `.claude/config/ccasp-state.json` | Update state cache |
+| `.claude/backups/` | Backup directory for replaced files |
+
+## Implementation Notes
+
+1. Read usage tracking from `.claude/config/usage-tracking.json`
+2. For each customized asset type (commands, skills, agents, hooks):
+   - Get local version from `.claude/{type}/`
+   - Get template from CCASP package installation
+   - Compare contents and generate diff
+3. Display findings and prompt for decisions
+4. Apply updates with backups
+5. Update tracking file to reflect new state

package/templates/hooks/ccasp-update-check.template.js

@@ -3,6 +3,7 @@
  *
  * Automatically checks for npm updates when Claude Code starts.
  * Runs on first UserPromptSubmit per session, caches results for 1 hour.
+ * Also detects customized assets that may need smart merge during updates.
  *
  * Event: UserPromptSubmit
  */
@@ -14,6 +15,7 @@ const path = require('path');
 const PACKAGE_NAME = 'claude-cli-advanced-starter-pack';
 const CACHE_DURATION = 60 * 60 * 1000; // 1 hour
 const STATE_FILE = '.claude/config/ccasp-state.json';
+const USAGE_FILE = '.claude/config/usage-tracking.json';
 const SESSION_MARKER = '.claude/config/.ccasp-session-checked';
 
 /**
@@ -39,6 +41,7 @@ function loadState() {
     updateHighlights: [],
     updateFirstDisplayed: false,
     dismissedUntil: 0,
+    projectImplCompleted: false,
   };
 }
 
@@ -184,6 +187,65 @@ function markSessionChecked() {
   fs.writeFileSync(markerPath, Date.now().toString(), 'utf8');
 }
 
+/**
+ * Load usage tracking data
+ */
+function loadUsageTracking() {
+  const trackingPath = path.join(process.cwd(), USAGE_FILE);
+
+  if (fs.existsSync(trackingPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(trackingPath, 'utf8'));
+    } catch {
+      // Return default
+    }
+  }
+
+  return {
+    version: '1.0.0',
+    assets: { commands: {}, skills: {}, agents: {}, hooks: {} },
+    _lastModified: null,
+  };
+}
+
+/**
+ * Get customized assets that have been used
+ */
+function getCustomizedUsedAssets() {
+  const tracking = loadUsageTracking();
+  const result = { commands: [], skills: [], agents: [], hooks: [] };
+
+  for (const [type, assets] of Object.entries(tracking.assets || {})) {
+    if (!result[type]) continue;
+
+    for (const [name, data] of Object.entries(assets || {})) {
+      if (data.customized && data.useCount > 0) {
+        result[type].push({
+          name,
+          useCount: data.useCount,
+          lastUsed: data.lastUsed,
+        });
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Count total customized assets
+ */
+function countCustomizedAssets() {
+  const assets = getCustomizedUsedAssets();
+  let count = 0;
+
+  for (const list of Object.values(assets)) {
+    count += list.length;
+  }
+
+  return count;
+}
+
 /**
  * Main hook handler
  */
@@ -231,8 +293,21 @@ module.exports = async function ccaspUpdateCheck(context) {
       state.updateFirstDisplayed = false;
       state.lastSeenUpdateVersion = latestVersion;
     }
+
+    // Check for customized assets that may need smart merge
+    const customizedCount = countCustomizedAssets();
+    if (customizedCount > 0) {
+      state.customizedAssetsCount = customizedCount;
+      state.customizedAssets = getCustomizedUsedAssets();
+      state.smartMergeAvailable = true;
+    } else {
+      state.customizedAssetsCount = 0;
+      state.customizedAssets = null;
+      state.smartMergeAvailable = false;
+    }
   } else {
     state.updateHighlights = [];
+    state.smartMergeAvailable = false;
   }
 
   // Save state