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

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/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,20 @@
 {
   "releases": [
+    {
+      "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);
+}

package/src/utils/paths.js

@@ -0,0 +1,146 @@
+/**
+ * Cross-Platform Path Utilities
+ *
+ * Centralized path handling for Windows/macOS/Linux compatibility.
+ * All path operations should use these utilities to ensure consistency.
+ */
+
+import { join, normalize, sep } from 'path';
+import { homedir } from 'os';
+
+/**
+ * Normalize a path to use forward slashes (for comparison and storage)
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Path with forward slashes
+ */
+export function toForwardSlashes(filePath) {
+  if (!filePath) return filePath;
+  return filePath.replace(/\\/g, '/');
+}
+
+/**
+ * Normalize a path to use the platform's native separator
+ * @param {string} filePath - Path to normalize
+ * @returns {string} Path with native separators
+ */
+export function toNativePath(filePath) {
+  if (!filePath) return filePath;
+  return filePath.replace(/[/\\]/g, sep);
+}
+
+/**
+ * Compare two paths for equality (cross-platform safe)
+ * @param {string} path1 - First path
+ * @param {string} path2 - Second path
+ * @returns {boolean} True if paths are equivalent
+ */
+export function pathsEqual(path1, path2) {
+  if (!path1 || !path2) return path1 === path2;
+  const norm1 = toForwardSlashes(path1).replace(/\/$/, '').toLowerCase();
+  const norm2 = toForwardSlashes(path2).replace(/\/$/, '').toLowerCase();
+  return norm1 === norm2;
+}
+
+/**
+ * Get the last segment of a path (cross-platform safe)
+ * @param {string} filePath - Path to extract from
+ * @returns {string} Last segment of the path
+ */
+export function getPathSegment(filePath) {
+  if (!filePath) return '';
+  return filePath.split(/[/\\]/).pop() || '';
+}
+
+/**
+ * Build a .claude-relative path string for use in config/templates
+ * Always uses forward slashes for consistency in JSON/templates
+ * @param {...string} segments - Path segments after .claude/
+ * @returns {string} Path string like ".claude/hooks/file.js"
+ */
+export function claudeRelativePath(...segments) {
+  return '.claude/' + segments.join('/');
+}
+
+/**
+ * Build an absolute path to a .claude directory item
+ * @param {string} baseDir - Project root directory
+ * @param {...string} segments - Path segments after .claude/
+ * @returns {string} Absolute path using native separators
+ */
+export function claudeAbsolutePath(baseDir, ...segments) {
+  return join(baseDir, '.claude', ...segments);
+}
+
+/**
+ * Get the user's home directory (cross-platform)
+ * @returns {string} Home directory path
+ */
+export function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+/**
+ * Build a path relative to user's home directory
+ * @param {...string} segments - Path segments after home
+ * @returns {string} Absolute path using native separators
+ */
+export function homeRelativePath(...segments) {
+  return join(getHomeDir(), ...segments);
+}
+
+/**
+ * Build a path to global .claude directory
+ * @param {...string} segments - Path segments after ~/.claude/
+ * @returns {string} Absolute path using native separators
+ */
+export function globalClaudePath(...segments) {
+  return join(getHomeDir(), '.claude', ...segments);
+}
+
+/**
+ * Check if running on Windows
+ * @returns {boolean} True if Windows
+ */
+export function isWindows() {
+  return process.platform === 'win32';
+}
+
+/**
+ * Get the appropriate command existence checker
+ * @returns {string} 'where' on Windows, 'which' on Unix
+ */
+export function getWhichCommand() {
+  return isWindows() ? 'where' : 'which';
+}
+
+/**
+ * Normalize line endings to Unix style (LF)
+ * @param {string} content - Content to normalize
+ * @returns {string} Content with Unix line endings
+ */
+export function normalizeLineEndings(content) {
+  if (!content) return content;
+  return content.replace(/\r\n/g, '\n');
+}
+
+/**
+ * Build a Node.js command that works cross-platform
+ * Uses forward slashes which Node.js handles on all platforms
+ * @param {string} scriptPath - Path to the script (relative to project root)
+ * @returns {string} Command string like "node .claude/hooks/script.js"
+ */
+export function nodeCommand(scriptPath) {
+  // Node.js handles forward slashes on all platforms
+  const normalizedPath = toForwardSlashes(scriptPath);
+  return `node ${normalizedPath}`;
+}
+
+/**
+ * Ensure a path uses consistent separators for storage/comparison
+ * Stores with forward slashes, converts to native when needed for fs operations
+ * @param {string} filePath - Path to store
+ * @returns {string} Normalized path for storage
+ */
+export function storagePath(filePath) {
+  return toForwardSlashes(filePath);
+}