claude-cli-advanced-starter-pack 1.8.4 → 1.8.6

package/templates/commands/detect-tech-stack.template.md

@@ -0,0 +1,137 @@
+---
+description: Re-run tech stack detection and update configuration
+---
+
+# /detect-tech-stack - Tech Stack Analysis
+
+Re-analyze the project's tech stack and update `.claude/config/tech-stack.json`.
+
+## Purpose
+
+Issue #8: Tech stack detection previously only ran during terminal phase (ccasp init).
+This command allows re-running detection from within Claude CLI to:
+- Detect new dependencies added since initial setup
+- Update framework versions
+- Refresh configuration for agents, skills, and hooks
+
+## Execution Steps
+
+### Step 1: Read Current Tech Stack
+
+```bash
+cat .claude/config/tech-stack.json 2>/dev/null || echo "{}"
+```
+
+Save as `previousStack` for comparison.
+
+### Step 2: Detect Current Stack
+
+Analyze the following files to build the new tech stack:
+
+**Package Managers:**
+- `package.json` → Node.js/npm project
+- `pyproject.toml` or `requirements.txt` → Python project
+- `Cargo.toml` → Rust project
+- `go.mod` → Go project
+- `pom.xml` or `build.gradle` → Java project
+
+**Frontend Frameworks (from package.json):**
+- `react` → React
+- `vue` → Vue.js
+- `@angular/core` → Angular
+- `svelte` → Svelte
+- `next` → Next.js
+- `nuxt` → Nuxt.js
+- `vite` → Vite bundler
+
+**Backend Frameworks:**
+- `express` → Express.js
+- `fastify` → Fastify
+- `@nestjs/core` → NestJS
+- `fastapi` (Python) → FastAPI
+- `django` (Python) → Django
+- `flask` (Python) → Flask
+
+**Testing Frameworks:**
+- `jest` → Jest
+- `vitest` → Vitest
+- `playwright` → Playwright
+- `cypress` → Cypress
+- `pytest` (Python) → Pytest
+
+**Database:**
+- `prisma` → Prisma ORM
+- `drizzle-orm` → Drizzle
+- `mongoose` → MongoDB
+- `pg` or `postgres` → PostgreSQL
+- `mysql2` → MySQL
+
+**Deployment:**
+Check for config files:
+- `wrangler.toml` → Cloudflare
+- `railway.json` or `railway.toml` → Railway
+- `vercel.json` → Vercel
+- `netlify.toml` → Netlify
+- `Dockerfile` → Docker
+
+### Step 3: Compare and Report Changes
+
+Compare `previousStack` with newly detected stack:
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  📊 Tech Stack Analysis                                       ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Language: {{language}}                                       ║
+║  Frontend: {{frontend.framework}} + {{frontend.bundler}}      ║
+║  Backend:  {{backend.framework}}                              ║
+║  Database: {{database.type}}                                  ║
+║  Testing:  {{testing.frameworks}}                             ║
+║  Deploy:   {{deployment.platform}}                            ║
+║                                                               ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Changes Detected:                                            ║
+║  [+] Added: (list new dependencies)                           ║
+║  [-] Removed: (list removed dependencies)                     ║
+║  [~] Updated: (list version changes)                          ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+### Step 4: Update tech-stack.json
+
+Write the updated configuration:
+
+```bash
+# Backup current config
+cp .claude/config/tech-stack.json .claude/config/tech-stack.json.bak
+
+# Write new config (use actual detected values)
+```
+
+### Step 5: Suggest Agent/Skill Updates
+
+Based on detected changes, recommend:
+
+| Change | Recommendation |
+|--------|----------------|
+| Added Playwright | Enable E2E testing skill |
+| Added Prisma | Enable database agent |
+| Added React 19 | Update component patterns |
+| New test framework | Configure test runner |
+
+## Output
+
+After completion, display:
+
+1. **Summary** of detected tech stack
+2. **Diff** showing what changed since last detection
+3. **Recommendations** for updating CCASP configuration
+4. **Restart reminder** if significant changes detected
+
+## Related Commands
+
+- `/claude-audit` - Audit CLAUDE.md configuration
+- `/update-smart` - Smart update manager
+- `/project-impl` - Project implementation agent

package/templates/commands/menu-for-happy-ui.template.md

@@ -0,0 +1,109 @@
+---
+description: Mobile-friendly menu optimized for Happy.Engineering CLI (no overflow)
+model: sonnet
+---
+
+# /menu-for-happy-ui - Mobile-Optimized CCASP Menu
+
+Display the CCASP menu in a mobile-friendly format that doesn't overflow on small screens.
+
+## Purpose
+
+This command is a fallback for when automatic Happy CLI detection fails. It forces the mobile-optimized menu layout regardless of environment.
+
+## When to Use
+
+- Running CCASP through Happy Coder mobile app
+- Using a narrow terminal window
+- Automatic detection (`HAPPY_*` env vars) not working
+- Preference for compact menu layout
+
+## Mobile Menu Features
+
+- **Max 40 character width** - No horizontal scrolling
+- **Single-column layout** - Easy vertical scrolling
+- **Minimal decorations** - Less visual noise
+- **Inline panel** - No new window launch (works with Happy)
+
+## Menu Layout
+
+```
+╔══════════════════════════════════╗
+║ CCASP v1.x                       ║
+║ Mobile Menu                      ║
+╚══════════════════════════════════╝
+ ✓ Configured
+
+1) Create Task
+2) Decompose Issue
+3) Sync Tasks
+──────────────────────────────────
+4) Setup
+5) List Tasks
+6) Install Command
+──────────────────────────────────
+P) Panel (inline)
+T) Test Setup
+A) Agent Creator
+M) MCP Explorer
+──────────────────────────────────
+S) Settings
+?) Help
+Q) Exit
+```
+
+## Instructions for Claude
+
+When this command is invoked:
+
+1. **Display Mobile Banner**
+   - Use 36-character width box
+   - Show version number (truncated)
+   - Show configuration status
+
+2. **Present Menu Options**
+   - Single column with numbered shortcuts
+   - Separator lines using `─` (34 chars)
+   - No descriptions (too wide for mobile)
+
+3. **Handle Selection**
+   - Route to appropriate handler
+   - For panel: display inline (no new window)
+   - Return to menu after each action
+
+4. **Settings Submenu**
+   - Same compact format
+   - Quick access to: GitHub, Deployment, Tunnel, Token, Happy
+
+## Comparison with Standard Menu
+
+| Feature | Standard | Mobile |
+|---------|----------|--------|
+| Width | 76 chars | 36 chars |
+| Columns | Multi | Single |
+| Descriptions | Full | None |
+| Panel launch | New window | Inline |
+| ASCII art | Full banner | Minimal |
+
+## Automatic Detection
+
+CCASP automatically detects Happy CLI via environment variables:
+
+```javascript
+// Auto-detected when any of these are set:
+process.env.HAPPY_HOME_DIR
+process.env.HAPPY_SERVER_URL
+process.env.HAPPY_WEBAPP_URL
+```
+
+If these are set, `/menu` automatically uses mobile layout. Use `/menu-for-happy-ui` only when auto-detection fails.
+
+## Related Commands
+
+- `/menu` - Standard menu (auto-detects Happy)
+- `/happy-start` - Initialize Happy Mode session
+- `/ccasp-panel` - Standard panel (new window)
+
+---
+
+*For Happy.Engineering mobile CLI users*

package/templates/commands/menu-issues-list.template.md

@@ -260,6 +260,78 @@ gh issue edit [NUMBER] --body "$(gh issue view [NUMBER] --json body -q .body)
 
 ---
 
+### Step 6: After Task Completion - Close Issue Prompt
+
+**CRITICAL: After ALL TodoWrite tasks are marked complete AND a commit is created, ALWAYS offer to close the issue.**
+
+This step triggers when:
+1. All tasks in TodoWrite are marked `completed`
+2. A git commit has been made with changes
+
+Display completion summary:
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ All Tasks Completed                                       ║
+╠═══════════════════════════════════════════════════════════════╣
+║                                                               ║
+║  Issue: #[NUMBER] - [TITLE]                                   ║
+║  Commit: [SHORT_SHA] - [COMMIT_MSG_FIRST_LINE]                ║
+║  Tasks: [X] completed                                         ║
+║                                                               ║
+╠═══════════════════════════════════════════════════════════════╣
+║  [C] Close issue with comment                                 ║
+║  [P] Push to origin + close issue                             ║
+║  [K] Keep issue open                                          ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+Then ask:
+
+```
+header: "Issue"
+question: "All tasks complete. Close issue #[NUMBER]?"
+options:
+  - label: "C - Close with comment"
+    description: "Add completion summary and close"
+  - label: "P - Push + Close"
+    description: "Push commit to origin, then close"
+  - label: "K - Keep open"
+    description: "Leave issue open for follow-up"
+```
+
+**Handle Close Actions:**
+
+**C (Close with comment):**
+```bash
+gh issue close [NUMBER] --comment "All tasks completed in commit [SHA].
+
+## Completed Tasks
+- ✅ Task 1
+- ✅ Task 2
+...
+
+Ready for release."
+```
+
+**P (Push + Close):**
+```bash
+git push origin HEAD
+gh issue close [NUMBER] --comment "All tasks completed and pushed in commit [SHA].
+
+## Completed Tasks
+- ✅ Task 1
+- ✅ Task 2
+...
+
+Ready for release."
+```
+
+**K (Keep open):**
+Display: "Issue #[NUMBER] kept open for follow-up."
+
+---
+
 ## MOBILE OPTIMIZATION
 
 - Single character inputs (A, B, C, S, V, X)

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

@@ -89,15 +89,50 @@ function getCurrentVersion() {
 
 /**
  * Check npm for latest version
+ * Issue #8: Added npm registry API fallback for Windows compatibility
  */
 function checkLatestVersion() {
+  // Try npm CLI first
   try {
     const result = execSync(`npm view ${PACKAGE_NAME} version`, {
       encoding: 'utf8',
       timeout: 10000,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-    return result.trim();
+    const version = result.trim();
+    if (version && /^\d+\.\d+\.\d+/.test(version)) {
+      return version;
+    }
+  } catch {
+    // npm CLI failed, try fallback
+  }
+
+  // Fallback: Direct npm registry API call
+  try {
+    const https = require('https');
+    return new Promise((resolve) => {
+      const req = https.get(
+        `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+        { timeout: 8000 },
+        (res) => {
+          let data = '';
+          res.on('data', (chunk) => (data += chunk));
+          res.on('end', () => {
+            try {
+              const pkg = JSON.parse(data);
+              resolve(pkg.version || null);
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(null);
+      });
+    });
   } catch {
     return null;
   }

package/templates/hooks/github-progress-hook.template.cjs

@@ -0,0 +1,248 @@
+/**
+ * GitHub Progress Hook
+ *
+ * Automatically updates GitHub issues as tasks are completed.
+ * Monitors TodoWrite calls and syncs progress to linked GitHub issues.
+ *
+ * Event: PostToolUse
+ * Matcher: TodoWrite
+ *
+ * This hook reads from stdin (Claude Code passes tool info there)
+ * and updates the linked GitHub issue with progress comments.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration - parse from tech-stack.json dynamically
+function loadConfig() {
+  try {
+    const techStackPath = path.join(process.cwd(), '.claude', 'config', 'tech-stack.json');
+    if (fs.existsSync(techStackPath)) {
+      const techStack = JSON.parse(fs.readFileSync(techStackPath, 'utf8'));
+      const vc = techStack.versionControl || {};
+      const repo = vc.repository || '';
+      const [owner, repoName] = repo.includes('/') ? repo.split('/') : ['', ''];
+
+      return {
+        owner: owner,
+        repo: repoName,
+        projectNumber: vc.projectBoard?.number || null,
+        enabled: !!vc.projectBoard?.type && !!owner && !!repoName,
+      };
+    }
+  } catch (e) {
+    // Silent fail - config not available
+  }
+  return { owner: '', repo: '', projectNumber: null, enabled: false };
+}
+
+const PROGRESS_FILE = '.claude/hooks/cache/github-progress.json';
+
+/**
+ * Load progress tracking data
+ */
+function loadProgress() {
+  const progressPath = path.join(process.cwd(), PROGRESS_FILE);
+
+  if (fs.existsSync(progressPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(progressPath, 'utf8'));
+    } catch (error) {
+      // Could not parse, return default
+    }
+  }
+
+  return {
+    linkedIssue: null,
+    tasks: [],
+    completedTasks: [],
+    lastUpdate: null,
+  };
+}
+
+/**
+ * Save progress tracking data
+ */
+function saveProgress(progress) {
+  const progressPath = path.join(process.cwd(), PROGRESS_FILE);
+  const progressDir = path.dirname(progressPath);
+
+  if (!fs.existsSync(progressDir)) {
+    fs.mkdirSync(progressDir, { recursive: true });
+  }
+
+  progress.lastUpdate = new Date().toISOString();
+  fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf8');
+}
+
+/**
+ * Check if gh CLI is available
+ */
+function hasGhCli() {
+  try {
+    execSync('gh --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Update GitHub issue with progress comment
+ */
+function updateGitHubIssue(issueNumber, completedCount, totalCount, latestTask, config) {
+  if (!hasGhCli()) {
+    return false;
+  }
+
+  try {
+    // Create progress comment
+    const percentage = totalCount > 0 ? Math.round((completedCount / totalCount) * 100) : 0;
+    const progressBar = '█'.repeat(Math.floor(percentage / 10)) + '░'.repeat(10 - Math.floor(percentage / 10));
+
+    const comment = `### Progress Update
+
+${progressBar} ${percentage}% (${completedCount}/${totalCount} tasks)
+
+**Latest completed:** ${latestTask || 'N/A'}
+
+---
+*Auto-updated by Claude Code github-progress-hook*`;
+
+    // Add comment to issue - use file to avoid escaping issues
+    const cacheDir = path.join(process.cwd(), '.claude', 'hooks', 'cache');
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    const tmpFile = path.join(cacheDir, 'tmp-comment.md');
+    fs.writeFileSync(tmpFile, comment, 'utf8');
+
+    execSync(
+      `gh issue comment ${issueNumber} --repo ${config.owner}/${config.repo} --body-file "${tmpFile}"`,
+      { stdio: 'pipe' }
+    );
+
+    // Clean up temp file
+    try { fs.unlinkSync(tmpFile); } catch {}
+
+    console.log(`[github-progress] Updated issue #${issueNumber}: ${percentage}% complete`);
+    return true;
+  } catch (error) {
+    // Silent fail
+    return false;
+  }
+}
+
+/**
+ * Extract linked issue number from todos
+ */
+function findLinkedIssue(todos, progress) {
+  // Check if issue is already linked
+  if (progress.linkedIssue) {
+    return progress.linkedIssue;
+  }
+
+  // Look for issue reference in todo content (e.g., "Issue #11" or "#11")
+  for (const todo of todos) {
+    const content = todo.content || '';
+    const issueMatch = content.match(/(?:Issue\s*)?#(\d+)/i);
+    if (issueMatch) {
+      return parseInt(issueMatch[1], 10);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Main function - reads from stdin and processes TodoWrite
+ */
+async function main() {
+  const config = loadConfig();
+
+  // Skip if not configured
+  if (!config.enabled) {
+    return;
+  }
+
+  // Read stdin to get tool information
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8');
+  } catch {
+    // No stdin available
+    return;
+  }
+
+  let toolData;
+  try {
+    toolData = JSON.parse(input);
+  } catch {
+    // Invalid JSON
+    return;
+  }
+
+  // Check if this is a TodoWrite tool
+  const toolName = toolData.tool_name || toolData.name;
+  if (toolName !== 'TodoWrite') {
+    return;
+  }
+
+  // Get todos from input
+  const todos = toolData.tool_input?.todos || toolData.input?.todos || [];
+  if (todos.length === 0) {
+    return;
+  }
+
+  // Load progress tracking
+  const progress = loadProgress();
+
+  // Check for linked issue
+  const issueNumber = findLinkedIssue(todos, progress);
+
+  if (issueNumber && !progress.linkedIssue) {
+    progress.linkedIssue = issueNumber;
+    console.log(`[github-progress] Linked to issue #${issueNumber}`);
+  }
+
+  // Skip if no linked issue
+  if (!progress.linkedIssue) {
+    saveProgress(progress);
+    return;
+  }
+
+  // Count completed vs total tasks (excluding CONTEXT task)
+  const actualTodos = todos.filter(t => !t.content?.startsWith('CONTEXT:'));
+  const completedTodos = actualTodos.filter(t => t.status === 'completed');
+  const totalCount = actualTodos.length;
+  const completedCount = completedTodos.length;
+
+  // Find latest completed task
+  const latestCompleted = completedTodos[completedTodos.length - 1];
+  const latestTask = latestCompleted?.content || null;
+
+  // Check if progress changed (more tasks completed than before)
+  const previousCompleted = progress.completedTasks?.length || 0;
+
+  if (completedCount > previousCompleted) {
+    // Update GitHub issue
+    updateGitHubIssue(progress.linkedIssue, completedCount, totalCount, latestTask, config);
+
+    // Update progress tracking
+    progress.completedTasks = completedTodos.map(t => t.content);
+    progress.tasks = actualTodos.map(t => ({ content: t.content, status: t.status }));
+  }
+
+  // Save progress
+  saveProgress(progress);
+}
+
+// Run the hook
+main().catch(err => {
+  // Silently fail - don't break Claude Code
+  if (process.env.DEBUG) {
+    console.error('github-progress hook error:', err);
+  }
+});