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

package/src/commands/init.js

@@ -28,6 +28,8 @@ import {
   generateMergeExplanation,
   formatMergeOptions,
 } from '../utils/smart-merge.js';
+import { registerProject } from '../utils/global-registry.js';
+import { replacePlaceholders } from '../utils/template-engine.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -169,6 +171,18 @@ const AVAILABLE_COMMANDS = [
     category: 'GitHub',
     selected: true,
   },
+  {
+    name: 'menu-issues-list',
+    description: 'Mobile-friendly menu of open GitHub issues',
+    category: 'GitHub',
+    selected: true,
+  },
+  {
+    name: 'create-task-list-for-issue',
+    description: 'Start working on a GitHub issue by number',
+    category: 'GitHub',
+    selected: true,
+  },
   {
     name: 'phase-dev-plan',
     description: 'Create phased development plans (95%+ success rate)',
@@ -1410,10 +1424,206 @@ function generateSettingsLocalJson() {
   }, null, 2);
 }
 
+/**
+ * Run dev mode - rapid template testing workflow
+ * Loads existing tech-stack.json, processes templates, overwrites commands
+ */
+async function runDevMode(options = {}) {
+  const cwd = process.cwd();
+  const projectName = basename(cwd);
+  const claudeDir = join(cwd, '.claude');
+  const commandsDir = join(claudeDir, 'commands');
+  const hooksDir = join(claudeDir, 'hooks');
+  const configDir = join(claudeDir, 'config');
+  const techStackPath = join(configDir, 'tech-stack.json');
+
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.magenta.bold('  🔧 DEV MODE - Template Testing'));
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log('');
+  console.log(chalk.cyan(`  Project: ${chalk.bold(projectName)}`));
+  console.log(chalk.cyan(`  Location: ${cwd}`));
+  console.log('');
+
+  // Load existing tech-stack.json
+  let techStack = {};
+  if (existsSync(techStackPath)) {
+    try {
+      techStack = JSON.parse(readFileSync(techStackPath, 'utf8'));
+      console.log(chalk.green('  ✓ Loaded existing tech-stack.json'));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Could not parse tech-stack.json: ${err.message}`));
+    }
+  } else {
+    console.log(chalk.yellow('  ⚠ No tech-stack.json found - templates will have unprocessed placeholders'));
+  }
+
+  // Ensure directories exist
+  if (!existsSync(commandsDir)) {
+    mkdirSync(commandsDir, { recursive: true });
+    console.log(chalk.green('  ✓ Created .claude/commands/'));
+  }
+  if (!existsSync(hooksDir)) {
+    mkdirSync(hooksDir, { recursive: true });
+    console.log(chalk.green('  ✓ Created .claude/hooks/'));
+  }
+
+  // Identify custom commands (no matching template) to preserve
+  const templatesDir = join(__dirname, '..', '..', 'templates', 'commands');
+  const hooksTemplatesDir = join(__dirname, '..', '..', 'templates', 'hooks');
+
+  const templateCommandNames = existsSync(templatesDir)
+    ? readdirSync(templatesDir).filter(f => f.endsWith('.template.md')).map(f => f.replace('.template.md', ''))
+    : [];
+  const templateHookNames = existsSync(hooksTemplatesDir)
+    ? readdirSync(hooksTemplatesDir).filter(f => f.endsWith('.template.js')).map(f => f.replace('.template.js', ''))
+    : [];
+
+  // Find existing custom commands (those without matching templates)
+  const existingCommands = existsSync(commandsDir)
+    ? readdirSync(commandsDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''))
+    : [];
+  const customCommands = existingCommands.filter(cmd =>
+    !templateCommandNames.includes(cmd) &&
+    cmd !== 'menu' &&
+    cmd !== 'INDEX' &&
+    cmd !== 'README'
+  );
+
+  if (customCommands.length > 0) {
+    console.log(chalk.blue(`  📌 Preserving ${customCommands.length} custom command(s):`));
+    for (const cmd of customCommands) {
+      console.log(chalk.dim(`    • /${cmd}`));
+    }
+    console.log('');
+  }
+
+  console.log(chalk.bold('Processing and deploying templates...\n'));
+
+  const spinner = ora('Processing templates...').start();
+  const deployed = { commands: [], hooks: [], preserved: customCommands };
+  const failed = [];
+
+  // Get all command templates
+  if (existsSync(templatesDir)) {
+    const templateFiles = readdirSync(templatesDir).filter(f => f.endsWith('.template.md'));
+
+    for (const templateFile of templateFiles) {
+      const cmdName = templateFile.replace('.template.md', '');
+      const templatePath = join(templatesDir, templateFile);
+      const outputPath = join(commandsDir, `${cmdName}.md`);
+
+      try {
+        let content = readFileSync(templatePath, 'utf8');
+
+        // Process template with tech-stack values
+        const { content: processed, warnings } = replacePlaceholders(content, techStack, {
+          preserveUnknown: false,
+          warnOnMissing: false,
+        });
+
+        writeFileSync(outputPath, processed, 'utf8');
+        deployed.commands.push(cmdName);
+      } catch (err) {
+        failed.push({ name: cmdName, type: 'command', error: err.message });
+      }
+    }
+  }
+
+  // Also process hook templates
+  if (existsSync(hooksTemplatesDir)) {
+    const hookFiles = readdirSync(hooksTemplatesDir).filter(f => f.endsWith('.template.js'));
+
+    for (const hookFile of hookFiles) {
+      const hookName = hookFile.replace('.template.js', '');
+      const templatePath = join(hooksTemplatesDir, hookFile);
+      const outputPath = join(hooksDir, `${hookName}.js`);
+
+      try {
+        let content = readFileSync(templatePath, 'utf8');
+
+        // Process template with tech-stack values
+        const { content: processed } = replacePlaceholders(content, techStack, {
+          preserveUnknown: false,
+          warnOnMissing: false,
+        });
+
+        writeFileSync(outputPath, processed, 'utf8');
+        deployed.hooks.push(hookName);
+      } catch (err) {
+        failed.push({ name: hookName, type: 'hook', error: err.message });
+      }
+    }
+  }
+
+  // Generate menu command from scratch (uses COMMAND_TEMPLATES)
+  const menuTemplate = COMMAND_TEMPLATES['menu'];
+  if (menuTemplate) {
+    const installedAgents = existsSync(join(claudeDir, 'agents'))
+      ? readdirSync(join(claudeDir, 'agents')).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''))
+      : [];
+    const installedSkills = existsSync(join(claudeDir, 'skills'))
+      ? readdirSync(join(claudeDir, 'skills')).filter(f => !f.startsWith('.'))
+      : [];
+    const installedHooks = existsSync(hooksDir)
+      ? readdirSync(hooksDir).filter(f => f.endsWith('.js')).map(f => f.replace('.js', ''))
+      : [];
+
+    const menuContent = generateMenuCommand(projectName, deployed.commands, installedAgents, installedSkills, installedHooks);
+    writeFileSync(join(commandsDir, 'menu.md'), menuContent, 'utf8');
+    deployed.commands.push('menu');
+  }
+
+  // Generate INDEX.md
+  const indexContent = generateIndexFile(deployed.commands, projectName);
+  writeFileSync(join(commandsDir, 'INDEX.md'), indexContent, 'utf8');
+
+  // Generate README.md
+  const readmeContent = generateReadmeFile(deployed.commands, projectName);
+  writeFileSync(join(commandsDir, 'README.md'), readmeContent, 'utf8');
+
+  spinner.stop();
+
+  // Summary
+  console.log('');
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.green.bold('  ✓ DEV MODE: Templates Deployed'));
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log('');
+  console.log(chalk.cyan(`  Commands: ${deployed.commands.length} deployed`));
+  console.log(chalk.cyan(`  Hooks: ${deployed.hooks.length} deployed`));
+  if (deployed.preserved && deployed.preserved.length > 0) {
+    console.log(chalk.blue(`  Custom: ${deployed.preserved.length} preserved`));
+  }
+  if (failed.length > 0) {
+    console.log(chalk.yellow(`  Failed: ${failed.length}`));
+    for (const f of failed) {
+      console.log(chalk.red(`    • ${f.type}/${f.name}: ${f.error}`));
+    }
+  }
+  console.log('');
+  console.log(chalk.dim('  tech-stack.json: Preserved'));
+  console.log(chalk.dim('  settings.json: Preserved'));
+  if (deployed.preserved && deployed.preserved.length > 0) {
+    console.log(chalk.dim(`  Custom commands: ${deployed.preserved.join(', ')}`));
+  }
+  console.log('');
+  console.log(chalk.yellow.bold('  ⚠ Restart Claude Code CLI to use new commands'));
+  console.log('');
+
+  return { deployed, failed };
+}
+
 /**
  * Run the init wizard
  */
 export async function runInit(options = {}) {
+  // DEV MODE: Fast path for template testing
+  if (options.dev) {
+    showHeader('Claude CLI Advanced Starter Pack - DEV MODE');
+    return runDevMode(options);
+  }
+
   showHeader('Claude CLI Advanced Starter Pack - Project Setup');
 
   const cwd = process.cwd();
@@ -2416,6 +2626,20 @@ export async function runInit(options = {}) {
   writeFileSync(ccaspStatePath, JSON.stringify(ccaspState, null, 2), 'utf8');
   console.log(chalk.green(`  ✓ Updated ccasp-state.json (v${currentVersion})`));
 
+  // Register project in global registry (unless --no-register flag is set)
+  if (!options.noRegister) {
+    const isNewProject = registerProject(cwd, {
+      name: projectName,
+      version: currentVersion,
+      features: selectedFeatures
+    });
+    if (isNewProject) {
+      console.log(chalk.green(`  ✓ Registered project in global CCASP registry`));
+    } else {
+      console.log(chalk.dim(`  ○ Updated project in global CCASP registry`));
+    }
+  }
+
   // Show next steps
   console.log(chalk.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
   console.log(chalk.bold('Next Steps:\n'));

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/commands/uninstall.js

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, readdirSync, unlinkSync, rmdirSync, copyFileSync, statSync } from 'fs';
 import { join, basename, dirname } from 'path';
 import { createInterface } from 'readline';
+import { unregisterProject } from '../utils/global-registry.js';
 
 /**
  * Prompt user for confirmation
@@ -396,8 +397,14 @@ export async function runUninstall(options = {}) {
     }
   }
 
+  // Remove from global registry
+  const wasRegistered = unregisterProject(projectDir);
+  if (wasRegistered) {
+    console.log(chalk.green('  ✓ Removed from global CCASP registry'));
+  }
+
   // Done
-  console.log(chalk.green.bold('  ✓ CCASP uninstalled successfully!\n'));
+  console.log(chalk.green.bold('\n  ✓ CCASP uninstalled successfully!\n'));
 
   if (backups.size > 0) {
     console.log(chalk.dim('  Your backed-up files have been restored.'));

package/src/data/releases.json

@@ -1,5 +1,35 @@
 {
   "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",
+      "summary": "Release notes pending",
+      "highlights": [],
+      "newFeatures": {
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": [],
+        "other": []
+      },
+      "breaking": [],
+      "deprecated": []
+    },
     {
       "version": "1.5.0",
       "date": "2026-01-30",

package/src/utils/global-registry.js

@@ -0,0 +1,230 @@
+/**
+ * Global Project Registry
+ * Tracks all projects configured with CCASP across the system
+ * Location: ~/.claude/ccasp-registry.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import {
+  globalClaudePath,
+  getHomeDir,
+  toForwardSlashes,
+  pathsEqual,
+  getPathSegment
+} from './paths.js';
+
+/**
+ * Get the path to the global registry file
+ * @returns {string} Path to ~/.claude/ccasp-registry.json
+ */
+export function getRegistryPath() {
+  return globalClaudePath('ccasp-registry.json');
+}
+
+/**
+ * Get the global .claude directory path
+ * @returns {string} Path to ~/.claude/
+ */
+export function getGlobalClaudeDir() {
+  return join(getHomeDir(), '.claude');
+}
+
+/**
+ * Ensure the global .claude directory exists
+ */
+function ensureGlobalDir() {
+  const globalDir = getGlobalClaudeDir();
+  if (!existsSync(globalDir)) {
+    mkdirSync(globalDir, { recursive: true });
+  }
+}
+
+/**
+ * Load the global registry
+ * @returns {Object} Registry object with projects array and metadata
+ */
+export function loadRegistry() {
+  const registryPath = getRegistryPath();
+
+  if (!existsSync(registryPath)) {
+    return {
+      version: '1.0.0',
+      projects: [],
+      lastModified: null
+    };
+  }
+
+  try {
+    const content = readFileSync(registryPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    console.error(`Warning: Could not parse registry file: ${err.message}`);
+    return {
+      version: '1.0.0',
+      projects: [],
+      lastModified: null
+    };
+  }
+}
+
+/**
+ * Save the global registry
+ * @param {Object} registry - Registry object to save
+ */
+export function saveRegistry(registry) {
+  ensureGlobalDir();
+  const registryPath = getRegistryPath();
+
+  registry.lastModified = new Date().toISOString();
+
+  writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf-8');
+}
+
+/**
+ * Register a project in the global registry
+ * @param {string} projectPath - Absolute path to the project
+ * @param {Object} metadata - Optional metadata (name, version, features)
+ * @returns {boolean} True if newly registered, false if already existed
+ */
+export function registerProject(projectPath, metadata = {}) {
+  const registry = loadRegistry();
+
+  // Check if already registered (using cross-platform path comparison)
+  const existingIndex = registry.projects.findIndex(
+    p => pathsEqual(p.path, projectPath)
+  );
+
+  const projectEntry = {
+    path: projectPath,
+    name: metadata.name || getPathSegment(projectPath),
+    registeredAt: new Date().toISOString(),
+    lastInitAt: new Date().toISOString(),
+    ccaspVersion: metadata.version || 'unknown',
+    features: metadata.features || []
+  };
+
+  if (existingIndex >= 0) {
+    // Update existing entry
+    registry.projects[existingIndex] = {
+      ...registry.projects[existingIndex],
+      ...projectEntry,
+      registeredAt: registry.projects[existingIndex].registeredAt // Keep original registration date
+    };
+    saveRegistry(registry);
+    return false;
+  }
+
+  // Add new entry
+  registry.projects.push(projectEntry);
+  saveRegistry(registry);
+  return true;
+}
+
+/**
+ * Unregister a project from the global registry
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {boolean} True if removed, false if not found
+ */
+export function unregisterProject(projectPath) {
+  const registry = loadRegistry();
+
+  const initialLength = registry.projects.length;
+  registry.projects = registry.projects.filter(
+    p => !pathsEqual(p.path, projectPath)
+  );
+
+  if (registry.projects.length < initialLength) {
+    saveRegistry(registry);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get all registered projects
+ * @param {Object} options - Filter options
+ * @param {boolean} options.existsOnly - Only return projects that still exist on disk
+ * @returns {Array} Array of project entries
+ */
+export function getRegisteredProjects(options = {}) {
+  const registry = loadRegistry();
+  let projects = registry.projects;
+
+  if (options.existsOnly) {
+    projects = projects.filter(p => existsSync(p.path));
+  }
+
+  return projects;
+}
+
+/**
+ * Check if a project is registered
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {boolean} True if registered
+ */
+export function isProjectRegistered(projectPath) {
+  const registry = loadRegistry();
+
+  return registry.projects.some(
+    p => pathsEqual(p.path, projectPath)
+  );
+}
+
+/**
+ * Get registry statistics
+ * @returns {Object} Stats about registered projects
+ */
+export function getRegistryStats() {
+  const registry = loadRegistry();
+  const projects = registry.projects;
+
+  let existingCount = 0;
+  let missingCount = 0;
+
+  for (const project of projects) {
+    if (existsSync(project.path)) {
+      existingCount++;
+    } else {
+      missingCount++;
+    }
+  }
+
+  return {
+    total: projects.length,
+    existing: existingCount,
+    missing: missingCount,
+    lastModified: registry.lastModified
+  };
+}
+
+/**
+ * Clean up registry by removing projects that no longer exist
+ * @returns {number} Number of projects removed
+ */
+export function cleanupRegistry() {
+  const registry = loadRegistry();
+  const initialLength = registry.projects.length;
+
+  registry.projects = registry.projects.filter(p => existsSync(p.path));
+
+  const removed = initialLength - registry.projects.length;
+  if (removed > 0) {
+    saveRegistry(registry);
+  }
+
+  return removed;
+}
+
+/**
+ * Clear the entire registry
+ */
+export function clearRegistry() {
+  const registry = {
+    version: '1.0.0',
+    projects: [],
+    lastModified: new Date().toISOString()
+  };
+  saveRegistry(registry);
+}