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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cli-advanced-starter-pack",
-  "version": "1.8.4",
+  "version": "1.8.5",
   "description": "Advanced Claude Code CLI toolkit - agents, hooks, skills, MCP servers, phased development, and GitHub integration",
   "main": "src/index.js",
   "bin": {

package/src/cli/menu.js

@@ -20,11 +20,13 @@ import { runCreatePhaseDev, showPhasDevMainMenu } from '../commands/create-phase
 import { runExploreMcp, showExploreMcpMenu } from '../commands/explore-mcp.js';
 import { runClaudeAudit, showClaudeAuditMenu } from '../commands/claude-audit.js';
 import { runRoadmap, showRoadmapMenu } from '../commands/roadmap.js';
-import { launchPanel } from '../commands/panel.js';
+import { launchPanel, launchPanelInline } from '../commands/panel.js';
 import { hasTestingConfig } from '../testing/config.js';
 import { showHelp } from '../commands/help.js';
 import { hasValidConfig, getVersion, loadTechStack, saveTechStack } from '../utils.js';
 import { performVersionCheck, formatUpdateBanner } from '../utils/version-check.js';
+import { isHappyMode, shouldUseMobileUI } from '../utils/happy-detect.js';
+import { showMobileMenu, showMobilePanel, showMobileSettings, mobileReturnPrompt } from './mobile-menu.js';
 
 /**
  * Get bypass permissions status from settings.json
@@ -655,8 +657,15 @@ async function configureHappy(techStack) {
 
 /**
  * Show main interactive menu
+ * Automatically detects Happy CLI and switches to mobile-optimized UI
  */
 export async function showMainMenu() {
+  // Check if we should use mobile UI (Happy CLI detected or happyMode.enabled)
+  const techStack = loadTechStack();
+  if (shouldUseMobileUI(techStack)) {
+    return showMobileMainMenu();
+  }
+
   console.clear();
   console.log(chalk.cyan(BANNER));
   console.log('');
@@ -1063,3 +1072,164 @@ export function showWarning(message) {
 export function showInfo(message) {
   console.log(chalk.blue(`ℹ ${message}`));
 }
+
+/**
+ * Mobile-optimized main menu handler
+ * Routes actions from the mobile menu to their handlers
+ */
+async function showMobileMainMenu() {
+  const action = await showMobileMenu();
+
+  switch (action) {
+    case 'create':
+      const configured = hasValidConfig();
+      if (!configured) {
+        console.log(chalk.yellow('Setup required first.'));
+        const { proceed } = await inquirer.prompt([
+          { type: 'confirm', name: 'proceed', message: 'Run setup?', default: true }
+        ]);
+        if (proceed) await runSetup({});
+      } else {
+        await runCreate({});
+      }
+      break;
+
+    case 'decompose':
+      if (!hasValidConfig()) {
+        console.log(chalk.yellow('Setup required first.'));
+      } else {
+        await runDecompose({});
+      }
+      break;
+
+    case 'sync':
+      if (!hasValidConfig()) {
+        console.log(chalk.yellow('Setup required first.'));
+      } else {
+        await runSync({ subcommand: 'status' });
+      }
+      break;
+
+    case 'setup':
+      await runSetup({});
+      break;
+
+    case 'list':
+      if (!hasValidConfig()) {
+        console.log(chalk.yellow('Setup required first.'));
+      } else {
+        await runList({});
+      }
+      break;
+
+    case 'install':
+      await runInstall({});
+      break;
+
+    case 'panel-inline':
+      // Show panel inline instead of launching new window
+      await showMobilePanelLoop();
+      break;
+
+    case 'test-setup':
+      await runTestSetup({});
+      break;
+
+    case 'agent-creator':
+      await runCreateAgent({});
+      break;
+
+    case 'explore-mcp':
+      await showExploreMcpMenu();
+      break;
+
+    case 'project-settings':
+      await showMobileSettingsLoop();
+      break;
+
+    case 'help':
+      showHelp();
+      break;
+
+    case 'exit':
+      console.log(chalk.dim('Goodbye!'));
+      process.exit(0);
+  }
+
+  // Return to menu unless exiting
+  if (action !== 'exit') {
+    const back = await mobileReturnPrompt();
+    if (back) {
+      await showMobileMainMenu();
+    } else {
+      console.log(chalk.dim('Goodbye!'));
+      process.exit(0);
+    }
+  }
+}
+
+/**
+ * Mobile panel loop - inline panel without new window
+ */
+async function showMobilePanelLoop() {
+  while (true) {
+    const action = await showMobilePanel();
+
+    if (action === 'back') {
+      return;
+    }
+
+    // Copy command to clipboard and show instructions
+    console.log('');
+    console.log(chalk.cyan(`Command: ${action}`));
+    console.log(chalk.dim('Paste in Claude Code'));
+    console.log('');
+
+    // Try to copy to clipboard
+    try {
+      const { copyToClipboard } = await import('../panel/queue.js');
+      if (copyToClipboard(action)) {
+        console.log(chalk.green('✓ Copied to clipboard'));
+      }
+    } catch {
+      // Clipboard not available
+    }
+
+    await inquirer.prompt([
+      { type: 'input', name: 'continue', message: 'Enter to continue...' }
+    ]);
+  }
+}
+
+/**
+ * Mobile settings loop
+ */
+async function showMobileSettingsLoop() {
+  while (true) {
+    const action = await showMobileSettings();
+
+    if (action === 'back') {
+      return;
+    }
+
+    const techStack = loadTechStack();
+
+    switch (action) {
+      case 'github':
+        await configureGitHub(techStack);
+        break;
+      case 'deployment':
+        await configureDeployment(techStack);
+        break;
+      case 'tunnel':
+        await configureTunnel(techStack);
+        break;
+      case 'token':
+        await configureToken(techStack);
+        break;
+      case 'happy':
+        await configureHappy(techStack);
+        break;
+    }
+  }
+}

package/src/cli/mobile-menu.js

@@ -0,0 +1,230 @@
+/**
+ * Mobile-Optimized Menu System for Happy CLI
+ *
+ * Renders menus optimized for mobile screens (max 40 chars).
+ * Single-column layout, no overflow, minimal decorations.
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { getVersion, loadTechStack, hasValidConfig } from '../utils.js';
+import { isHappyMode, getMobileWidth } from '../utils/happy-detect.js';
+
+// Mobile-friendly banner (40 chars max)
+const MOBILE_BANNER = `
+${chalk.cyan('╔══════════════════════════════════╗')}
+${chalk.cyan('║')} ${chalk.bold('CCASP')} ${chalk.dim('v' + getVersion().slice(0, 5))}${' '.repeat(17)}${chalk.cyan('║')}
+${chalk.cyan('║')} ${chalk.dim('Mobile Menu')}${' '.repeat(21)}${chalk.cyan('║')}
+${chalk.cyan('╚══════════════════════════════════╝')}`;
+
+// Compact panel banner for mobile
+const MOBILE_PANEL_BANNER = `
+${chalk.cyan('╔══════════════════════════════════╗')}
+${chalk.cyan('║')} ${chalk.bold('CCASP Panel')}${' '.repeat(20)}${chalk.cyan('║')}
+${chalk.cyan('╚══════════════════════════════════╝')}`;
+
+/**
+ * Truncate text to fit mobile width
+ * @param {string} text - Text to truncate
+ * @param {number} maxLen - Maximum length
+ * @returns {string} Truncated text
+ */
+function truncate(text, maxLen = 30) {
+  if (!text) return '';
+  // Strip ANSI codes for length calculation
+  const plainText = text.replace(/\x1B\[[0-9;]*m/g, '');
+  if (plainText.length <= maxLen) return text;
+  return text.slice(0, maxLen - 2) + '..';
+}
+
+/**
+ * Format a menu item for mobile (single line)
+ * @param {string} key - Shortcut key
+ * @param {string} label - Item label
+ * @returns {string} Formatted menu item
+ */
+function formatMobileItem(key, label) {
+  const truncLabel = truncate(label, 28);
+  return `${chalk.yellow(key + ')')} ${truncLabel}`;
+}
+
+/**
+ * Show mobile-optimized main menu
+ */
+export async function showMobileMenu() {
+  console.clear();
+  console.log(MOBILE_BANNER);
+
+  const configured = hasValidConfig();
+
+  // Status line
+  if (configured) {
+    console.log(chalk.green(' ✓ Configured'));
+  } else {
+    console.log(chalk.yellow(' ⚠ Not configured'));
+  }
+  console.log('');
+
+  // Single-column menu items
+  const choices = [
+    { name: formatMobileItem('1', 'Create Task'), value: 'create' },
+    { name: formatMobileItem('2', 'Decompose Issue'), value: 'decompose' },
+    { name: formatMobileItem('3', 'Sync Tasks'), value: 'sync' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    { name: formatMobileItem('4', 'Setup'), value: 'setup' },
+    { name: formatMobileItem('5', 'List Tasks'), value: 'list' },
+    { name: formatMobileItem('6', 'Install Command'), value: 'install' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    { name: formatMobileItem('P', 'Panel (inline)'), value: 'panel-inline' },
+    { name: formatMobileItem('T', 'Test Setup'), value: 'test-setup' },
+    { name: formatMobileItem('A', 'Agent Creator'), value: 'agent-creator' },
+    { name: formatMobileItem('M', 'MCP Explorer'), value: 'explore-mcp' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    { name: formatMobileItem('S', 'Settings'), value: 'project-settings' },
+    { name: formatMobileItem('?', 'Help'), value: 'help' },
+    { name: formatMobileItem('Q', 'Exit'), value: 'exit' },
+  ];
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Select:',
+      choices,
+      pageSize: 12,
+    },
+  ]);
+
+  return action;
+}
+
+/**
+ * Show mobile-optimized panel menu (inline, no new window)
+ */
+export async function showMobilePanel() {
+  console.clear();
+  console.log(MOBILE_PANEL_BANNER);
+  console.log('');
+
+  // Single-column panel items
+  const choices = [
+    new inquirer.Separator(chalk.cyan(' Agents & Skills')),
+    { name: formatMobileItem('A', 'Create Agent'), value: '/create-agent' },
+    { name: formatMobileItem('H', 'Create Hook'), value: '/create-hook' },
+    { name: formatMobileItem('S', 'Create Skill'), value: '/create-skill' },
+    { name: formatMobileItem('M', 'Explore MCP'), value: '/explore-mcp' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    new inquirer.Separator(chalk.cyan(' Resources')),
+    { name: formatMobileItem('1', 'View Agents'), value: '/view-agents' },
+    { name: formatMobileItem('2', 'View Skills'), value: '/view-skills' },
+    { name: formatMobileItem('3', 'View Hooks'), value: '/view-hooks' },
+    { name: formatMobileItem('4', 'All Commands'), value: '/INDEX' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    new inquirer.Separator(chalk.cyan(' Quick Actions')),
+    { name: formatMobileItem('P', 'Phase Dev Plan'), value: '/phase-dev-plan' },
+    { name: formatMobileItem('G', 'GitHub Task'), value: '/github-task' },
+    { name: formatMobileItem('T', 'Run E2E Tests'), value: '/e2e-test' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    { name: formatMobileItem('B', 'Back'), value: 'back' },
+  ];
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Select:',
+      choices,
+      pageSize: 15,
+    },
+  ]);
+
+  return action;
+}
+
+/**
+ * Show mobile-optimized project settings
+ */
+export async function showMobileSettings() {
+  console.clear();
+  console.log(chalk.cyan('╔══════════════════════════════════╗'));
+  console.log(chalk.cyan('║') + chalk.bold(' Settings') + ' '.repeat(23) + chalk.cyan('║'));
+  console.log(chalk.cyan('╚══════════════════════════════════╝'));
+  console.log('');
+
+  const choices = [
+    { name: formatMobileItem('1', 'GitHub Board'), value: 'github' },
+    { name: formatMobileItem('2', 'Deployment'), value: 'deployment' },
+    { name: formatMobileItem('3', 'Tunnel'), value: 'tunnel' },
+    { name: formatMobileItem('4', 'Token Budget'), value: 'token' },
+    { name: formatMobileItem('5', 'Happy Mode'), value: 'happy' },
+    new inquirer.Separator(chalk.dim('─'.repeat(34))),
+    { name: formatMobileItem('B', 'Back'), value: 'back' },
+  ];
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'Select:',
+      choices,
+      pageSize: 10,
+    },
+  ]);
+
+  return action;
+}
+
+/**
+ * Show a mobile-friendly success message
+ * @param {string} message - Success message
+ */
+export function showMobileSuccess(message) {
+  console.log('');
+  console.log(chalk.green(`✓ ${truncate(message, 32)}`));
+  console.log('');
+}
+
+/**
+ * Show a mobile-friendly error message
+ * @param {string} message - Error message
+ */
+export function showMobileError(message) {
+  console.log('');
+  console.log(chalk.red(`✗ ${truncate(message, 32)}`));
+  console.log('');
+}
+
+/**
+ * Show a mobile-friendly info box
+ * @param {string} title - Box title
+ * @param {string[]} lines - Content lines
+ */
+export function showMobileBox(title, lines = []) {
+  const width = getMobileWidth() - 4; // Account for borders
+  console.log('');
+  console.log(chalk.cyan('┌' + '─'.repeat(width) + '┐'));
+  console.log(chalk.cyan('│') + ` ${truncate(title, width - 2)}`.padEnd(width) + chalk.cyan('│'));
+  console.log(chalk.cyan('├' + '─'.repeat(width) + '┤'));
+  for (const line of lines) {
+    console.log(chalk.cyan('│') + ` ${truncate(line, width - 2)}`.padEnd(width) + chalk.cyan('│'));
+  }
+  console.log(chalk.cyan('└' + '─'.repeat(width) + '┘'));
+  console.log('');
+}
+
+/**
+ * Prompt to return to menu (mobile version)
+ * @returns {Promise<boolean>} True if user wants to return
+ */
+export async function mobileReturnPrompt() {
+  console.log('');
+  const { back } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'back',
+      message: 'Back to menu?',
+      default: true,
+    },
+  ]);
+  return back;
+}

package/src/commands/panel.js

@@ -20,6 +20,7 @@ import {
   ensureQueueDir,
 } from '../panel/queue.js';
 import { getVersion } from '../utils.js';
+import { isHappyMode } from '../utils/happy-detect.js';
 
 // Panel ASCII Banner
 const PANEL_BANNER = `
@@ -249,8 +250,15 @@ export async function runPanel(options = {}) {
 
 /**
  * Launch panel in a new terminal window
+ * Automatically detects Happy CLI and falls back to inline mode
  */
 export async function launchPanel() {
+  // If Happy mode detected, use inline panel instead of new window
+  if (isHappyMode()) {
+    console.log(chalk.cyan('\n  Happy CLI detected - using inline panel\n'));
+    return launchPanelInline();
+  }
+
   console.log(chalk.cyan('\n  Launching CCASP Panel in new window...\n'));
 
   const ccaspPath = join(process.cwd(), 'node_modules', '.bin', 'ccasp');
@@ -295,3 +303,79 @@ export async function launchPanel() {
     console.log(chalk.dim(`  Run manually: ${chalk.white('ccasp panel')}\n`));
   }
 }
+
+/**
+ * Launch panel inline (mobile-friendly, no new window)
+ * Used when Happy CLI is detected or explicitly requested
+ */
+export async function launchPanelInline() {
+  const MOBILE_PANEL_BANNER = `
+${chalk.cyan('╔══════════════════════════════════╗')}
+${chalk.cyan('║')} ${chalk.bold('Panel')} ${chalk.dim('(inline)')}${' '.repeat(17)}${chalk.cyan('║')}
+${chalk.cyan('╚══════════════════════════════════╝')}`;
+
+  console.clear();
+  console.log(MOBILE_PANEL_BANNER);
+  console.log('');
+
+  // Simplified single-column panel for mobile
+  const sections = [
+    { header: 'Agents', items: [
+      { key: 'A', label: 'Create Agent', cmd: '/create-agent' },
+      { key: 'H', label: 'Create Hook', cmd: '/create-hook' },
+      { key: 'S', label: 'Create Skill', cmd: '/create-skill' },
+      { key: 'M', label: 'Explore MCP', cmd: '/explore-mcp' },
+    ]},
+    { header: 'Actions', items: [
+      { key: 'P', label: 'Phase Dev', cmd: '/phase-dev-plan' },
+      { key: 'G', label: 'GitHub Task', cmd: '/github-task' },
+      { key: 'T', label: 'E2E Tests', cmd: '/e2e-test' },
+    ]},
+  ];
+
+  // Build choices
+  const choices = [];
+  for (const section of sections) {
+    choices.push(new inquirer.Separator(chalk.cyan(` ${section.header}`)));
+    for (const item of section.items) {
+      choices.push({
+        name: `${chalk.yellow(item.key + ')')} ${item.label}`,
+        value: item.cmd,
+      });
+    }
+  }
+  choices.push(new inquirer.Separator(chalk.dim('─'.repeat(34))));
+  choices.push({ name: `${chalk.yellow('B)')} Back`, value: 'back' });
+
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: 'Select:',
+    choices,
+    pageSize: 12,
+  }]);
+
+  if (action === 'back') {
+    return;
+  }
+
+  // Show command and copy to clipboard
+  console.log('');
+  console.log(chalk.cyan(`Command: ${action}`));
+
+  const copied = copyToClipboard(action);
+  if (copied) {
+    console.log(chalk.green('✓ Copied to clipboard'));
+  }
+  console.log(chalk.dim('Paste in Claude Code'));
+  console.log('');
+
+  await inquirer.prompt([{
+    type: 'input',
+    name: 'continue',
+    message: 'Enter to continue...',
+  }]);
+
+  // Loop back to panel
+  return launchPanelInline();
+}

package/src/data/releases.json

@@ -1,5 +1,20 @@
 {
   "releases": [
+    {
+      "version": "1.8.5",
+      "date": "2026-01-31",
+      "summary": "Release notes pending",
+      "highlights": [],
+      "newFeatures": {
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": [],
+        "other": []
+      },
+      "breaking": [],
+      "deprecated": []
+    },
     {
       "version": "1.8.4",
       "date": "2026-01-31",

package/src/utils/happy-detect.js

@@ -0,0 +1,66 @@
+/**
+ * Happy CLI Detection Utility
+ *
+ * Detects if CCASP is running inside Happy Coder mobile CLI wrapper.
+ * Happy CLI sets HAPPY_* environment variables when active.
+ *
+ * @see https://github.com/slopus/happy-cli
+ */
+
+/**
+ * Check if running inside Happy CLI environment
+ * @returns {boolean} True if Happy CLI detected
+ */
+export function isHappyMode() {
+  return !!(
+    process.env.HAPPY_HOME_DIR ||
+    process.env.HAPPY_SERVER_URL ||
+    process.env.HAPPY_WEBAPP_URL ||
+    process.env.HAPPY_EXPERIMENTAL
+  );
+}
+
+/**
+ * Get Happy CLI configuration from environment
+ * @returns {object} Happy configuration details
+ */
+export function getHappyConfig() {
+  return {
+    detected: isHappyMode(),
+    homeDir: process.env.HAPPY_HOME_DIR || null,
+    serverUrl: process.env.HAPPY_SERVER_URL || 'https://api.cluster-fluster.com',
+    webappUrl: process.env.HAPPY_WEBAPP_URL || 'https://app.happy.engineering',
+    experimental: process.env.HAPPY_EXPERIMENTAL === 'true',
+    disableCaffeinate: process.env.HAPPY_DISABLE_CAFFEINATE === 'true',
+  };
+}
+
+/**
+ * Get recommended terminal width for mobile display
+ * @returns {number} Optimal width for mobile screens
+ */
+export function getMobileWidth() {
+  // Happy mobile UI typically works best at 40 chars
+  // to avoid horizontal scrolling on phone screens
+  return 40;
+}
+
+/**
+ * Check if we should use mobile-optimized UI
+ * Respects both Happy CLI detection and tech-stack.json happyMode.enabled
+ * @param {object} techStack - Optional tech-stack.json config
+ * @returns {boolean} True if mobile UI should be used
+ */
+export function shouldUseMobileUI(techStack = null) {
+  // Auto-detect Happy CLI environment
+  if (isHappyMode()) {
+    return true;
+  }
+
+  // Check tech-stack.json happyMode.enabled setting
+  if (techStack?.happyMode?.enabled) {
+    return true;
+  }
+
+  return false;
+}

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/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);
+  }
+});

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

@@ -1,197 +0,0 @@
-/**
- * GitHub Progress Hook
- *
- * Automatically updates GitHub issues as tasks are completed.
- * Monitors TodoWrite/TaskUpdate calls and syncs progress to linked GitHub issues.
- *
- * Event: PostToolUse
- * Priority: {{hooks.priorities.automation}}
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-// Configuration from tech-stack.json
-const CONFIG = {
-  owner: '{{versionControl.owner}}',
-  repo: '{{versionControl.repo}}',
-  projectNumber: {{versionControl.projectBoard.number}},
-  enabled: '{{versionControl.projectBoard.type}}' === 'github-projects',
-};
-
-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) {
-      console.warn('[github-progress] Could not parse progress file');
-    }
-  }
-
-  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
- */
-function updateGitHubIssue(issueNumber, completedTasks, totalTasks, latestTask) {
-  if (!hasGhCli()) {
-    console.warn('[github-progress] gh CLI not available');
-    return false;
-  }
-
-  try {
-    // Create progress comment
-    const percentage = Math.round((completedTasks / totalTasks) * 100);
-    const progressBar = '█'.repeat(Math.floor(percentage / 10)) + '░'.repeat(10 - Math.floor(percentage / 10));
-
-    const comment = `### Progress Update
-
-${progressBar} ${percentage}% (${completedTasks}/${totalTasks} tasks)
-
-**Latest completed:** ${latestTask || 'N/A'}
-
----
-*Auto-updated by Claude Code github-progress-hook*`;
-
-    // Add comment to issue
-    execSync(
-      `gh issue comment ${issueNumber} --repo ${CONFIG.owner}/${CONFIG.repo} --body "${comment.replace(/"/g, '\\"')}"`,
-      { stdio: 'ignore' }
-    );
-
-    return true;
-  } catch (error) {
-    console.warn('[github-progress] Failed to update GitHub:', error.message);
-    return false;
-  }
-}
-
-/**
- * Extract linked issue from task metadata or context
- */
-function findLinkedIssue(input, progress) {
-  // Check if issue is already linked
-  if (progress.linkedIssue) {
-    return progress.linkedIssue;
-  }
-
-  // Try to extract from task description
-  if (input && input.description) {
-    const issueMatch = input.description.match(/#(\d+)/);
-    if (issueMatch) {
-      return parseInt(issueMatch[1], 10);
-    }
-  }
-
-  // Try to extract from subject
-  if (input && input.subject) {
-    const issueMatch = input.subject.match(/#(\d+)/);
-    if (issueMatch) {
-      return parseInt(issueMatch[1], 10);
-    }
-  }
-
-  return null;
-}
-
-/**
- * Main hook handler
- */
-module.exports = async function githubProgressHook(context) {
-  // Skip if not configured
-  if (!CONFIG.enabled || !CONFIG.owner || !CONFIG.repo) {
-    return { continue: true };
-  }
-
-  const { tool, input } = context;
-
-  // Only process task-related tools
-  if (!['TodoWrite', 'TaskUpdate', 'TaskCreate'].includes(tool)) {
-    return { continue: true };
-  }
-
-  // Load progress tracking
-  const progress = loadProgress();
-
-  // Check for linked issue
-  const issueNumber = findLinkedIssue(input, progress);
-
-  if (issueNumber && !progress.linkedIssue) {
-    progress.linkedIssue = issueNumber;
-    console.log(`[github-progress] Linked to issue #${issueNumber}`);
-  }
-
-  // Track task completion
-  if (tool === 'TaskUpdate' && input && input.status === 'completed') {
-    const taskId = input.taskId;
-    if (taskId && !progress.completedTasks.includes(taskId)) {
-      progress.completedTasks.push(taskId);
-
-      // Update GitHub if we have a linked issue
-      if (progress.linkedIssue) {
-        const totalTasks = progress.tasks.length || progress.completedTasks.length;
-        updateGitHubIssue(
-          progress.linkedIssue,
-          progress.completedTasks.length,
-          totalTasks,
-          input.subject || `Task ${taskId}`
-        );
-      }
-    }
-  }
-
-  // Track new tasks
-  if (tool === 'TaskCreate' && input && input.subject) {
-    progress.tasks.push({
-      id: Date.now().toString(),
-      subject: input.subject,
-      created: new Date().toISOString(),
-    });
-  }
-
-  // Save updated progress
-  saveProgress(progress);
-
-  return { continue: true };
-};