claude-cli-advanced-starter-pack 1.0.12 → 1.0.14

package/package.json

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

package/src/commands/init.js

@@ -15,6 +15,19 @@ import { fileURLToPath } from 'url';
 import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
 import { getVersion } from '../utils.js';
 import { createBackup } from './setup-wizard.js';
+import {
+  loadUsageTracking,
+  getCustomizedUsedAssets,
+  isAssetCustomized,
+} from '../utils/version-check.js';
+import {
+  getAssetsNeedingMerge,
+  compareAssetVersions,
+  getLocalAsset,
+  getTemplateAsset,
+  generateMergeExplanation,
+  formatMergeOptions,
+} from '../utils/smart-merge.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -29,7 +42,7 @@ const OPTIONAL_FEATURES = [
     label: 'Token Budget Management',
     description: 'Monitor and manage Claude API token usage with automatic compaction warnings, archive suggestions, and respawn thresholds. Includes hooks that track usage per session.',
     commands: ['context-audit'],
-    hooks: ['token-budget-loader', 'context-guardian', 'tool-output-cacher'],
+    hooks: ['context-guardian'],  // Only include hooks with templates
     default: false,
     requiresPostConfig: false,
   },
@@ -38,7 +51,7 @@ const OPTIONAL_FEATURES = [
     label: 'Happy Engineering Integration',
     description: 'Integration with Happy Coder mobile app for remote session control, checkpoint management, and mobile-optimized responses. Requires Happy Coder app installed separately.',
     commands: ['happy-start'],
-    hooks: ['happy-checkpoint-manager', 'happy-title-generator', 'happy-mode-detector'],
+    hooks: ['happy-checkpoint-manager'],  // Only include hooks with templates
     default: false,
     requiresPostConfig: true,
   },
@@ -47,7 +60,7 @@ const OPTIONAL_FEATURES = [
     label: 'GitHub Project Board Integration',
     description: 'Connect Claude to your GitHub Project Board for automated issue creation, progress tracking, and PR merge automation. Requires gh CLI authentication.',
     commands: ['github-update', 'github-task-start'],
-    hooks: ['github-progress-hook', 'issue-completion-detector'],
+    hooks: ['github-progress-hook'],  // Only include hooks with templates
     default: true,
     requiresPostConfig: true,
   },
@@ -245,6 +258,12 @@ const AVAILABLE_COMMANDS = [
     category: 'Maintenance',
     selected: true,
   },
+  {
+    name: 'update-smart',
+    description: 'Smart merge manager for customized assets during updates',
+    category: 'Maintenance',
+    selected: true,
+  },
 ];
 
 /**
@@ -1482,7 +1501,7 @@ module.exports = async function ccaspUpdateCheck(context) {
 }
 
 /**
- * Generate settings.json with CCASP update check hook
+ * Generate settings.json with CCASP update check hook and usage tracking
  */
 function generateSettingsJson(projectName) {
   return JSON.stringify({
@@ -1502,6 +1521,17 @@ function generateSettingsJson(projectName) {
             }
           ]
         }
+      ],
+      "PostToolUse": [
+        {
+          "matcher": "Skill|Read",
+          "hooks": [
+            {
+              "type": "command",
+              "command": "node .claude/hooks/usage-tracking.js"
+            }
+          ]
+        }
       ]
     }
   }, null, 2);
@@ -1738,6 +1768,19 @@ export async function runInit(options = {}) {
     console.log(chalk.blue('  ○ hooks/ccasp-update-check.js exists (preserved)'));
   }
 
+  // Deploy the usage tracking hook (tracks command/skill/agent usage for smart merge)
+  const usageTrackingHookPath = join(hooksDir, 'usage-tracking.js');
+  if (!existsSync(usageTrackingHookPath)) {
+    const templatePath = join(__dirname, '..', '..', 'templates', 'hooks', 'usage-tracking.template.js');
+    if (existsSync(templatePath)) {
+      const hookContent = readFileSync(templatePath, 'utf8');
+      writeFileSync(usageTrackingHookPath, hookContent, 'utf8');
+      console.log(chalk.green('  ✓ Created hooks/usage-tracking.js (smart merge tracking)'));
+    }
+  } else {
+    console.log(chalk.blue('  ○ hooks/usage-tracking.js exists (preserved)'));
+  }
+
   console.log('');
 
   // Step 4: Select optional features
@@ -1775,6 +1818,25 @@ export async function runInit(options = {}) {
   const enabledFeatures = OPTIONAL_FEATURES.filter((f) => selectedFeatures.includes(f.name));
   const featuresRequiringConfig = enabledFeatures.filter((f) => f.requiresPostConfig);
 
+  // Collect feature-specific commands and hooks to deploy
+  const featureCommands = [];
+  const featureHooks = [];
+  for (const feature of enabledFeatures) {
+    featureCommands.push(...feature.commands);
+    featureHooks.push(...feature.hooks);
+  }
+
+  if (featureCommands.length > 0) {
+    console.log('');
+    console.log(chalk.green(`  ✓ Selected features will add ${featureCommands.length} command(s):`));
+    console.log(chalk.dim(`    ${featureCommands.map(c => '/' + c).join(', ')}`));
+  }
+
+  if (featureHooks.length > 0) {
+    console.log(chalk.green(`  ✓ Selected features will add ${featureHooks.length} hook(s):`));
+    console.log(chalk.dim(`    ${featureHooks.join(', ')}`));
+  }
+
   if (featuresRequiringConfig.length > 0) {
     console.log('');
     console.log(chalk.yellow('  ℹ The following features require configuration after installation:'));
@@ -1835,67 +1897,246 @@ export async function runInit(options = {}) {
     },
   ]);
 
-  // Always include required commands
+  // Always include required commands AND feature-specific commands
   const requiredCommands = AVAILABLE_COMMANDS.filter(c => c.required).map(c => c.name);
-  const finalCommands = [...new Set([...requiredCommands, ...selectedCommands])];
+  const finalCommands = [...new Set([...requiredCommands, ...selectedCommands, ...featureCommands])];
 
   if (finalCommands.length === 0) {
     showWarning('No commands selected. Nothing to install.');
     return;
   }
 
+  // Show what feature commands were auto-added
+  const autoAddedCommands = featureCommands.filter(c => !selectedCommands.includes(c) && !requiredCommands.includes(c));
+  if (autoAddedCommands.length > 0) {
+    console.log(chalk.cyan(`  ℹ Auto-including ${autoAddedCommands.length} feature command(s): ${autoAddedCommands.map(c => '/' + c).join(', ')}`));
+  }
+
   console.log('');
 
   // Step 6: Check for existing commands that would be overwritten
   const commandsToOverwrite = finalCommands.filter(cmd => existingCmdNames.includes(cmd));
 
+  // Track commands that need smart merge handling
+  const smartMergeDecisions = {};
+
   let overwrite = options.force || false;
   if (commandsToOverwrite.length > 0 && !overwrite) {
-    console.log(chalk.yellow.bold('  ⚠ The following commands already exist:'));
-    for (const cmd of commandsToOverwrite) {
-      console.log(chalk.yellow(`    • /${cmd}`));
-    }
-    console.log('');
+    // Check for customized assets that have been used
+    const assetsNeedingMerge = getAssetsNeedingMerge(process.cwd());
+    const customizedCommands = commandsToOverwrite.filter(cmd =>
+      assetsNeedingMerge.commands?.some(a => a.name === cmd)
+    );
+
+    // Show smart merge prompt for customized commands
+    if (customizedCommands.length > 0) {
+      console.log(chalk.cyan.bold('\n  🔀 Smart Merge Available'));
+      console.log(chalk.dim('  The following commands have been customized and used:\n'));
+
+      for (const cmd of customizedCommands) {
+        const assetInfo = assetsNeedingMerge.commands.find(a => a.name === cmd);
+        console.log(chalk.cyan(`    • /${cmd}`));
+        console.log(chalk.dim(`      Used ${assetInfo.usageData.useCount} time(s), last: ${new Date(assetInfo.usageData.lastUsed).toLocaleDateString()}`));
+        console.log(chalk.dim(`      Change: ${assetInfo.comparison.significance.level} significance - ${assetInfo.comparison.summary}`));
+      }
+      console.log('');
 
-    const { overwriteChoice } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'overwriteChoice',
-        message: 'How would you like to handle existing commands?',
-        choices: [
-          { name: 'Skip existing - only install new commands (recommended)', value: 'skip' },
-          { name: 'Overwrite with backup - save existing to .claude/backups/ first', value: 'backup' },
-          { name: 'Overwrite all - replace existing (no backup)', value: 'overwrite' },
-          { name: 'Cancel installation', value: 'cancel' },
-        ],
-      },
-    ]);
+      const { smartMergeAction } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'smartMergeAction',
+          message: 'How would you like to handle your customized commands?',
+          choices: [
+            { name: '🔍 Explore each one - Let Claude explain the changes', value: 'explore' },
+            { name: '📋 Skip all customized - Keep your versions', value: 'skip-customized' },
+            { name: '🔄 Replace all - Use new versions (lose customizations)', value: 'replace-all' },
+            { name: '❌ Cancel installation', value: 'cancel' },
+          ],
+        },
+      ]);
+
+      if (smartMergeAction === 'cancel') {
+        console.log(chalk.dim('\nCancelled. No changes made.'));
+        return;
+      }
 
-    if (overwriteChoice === 'cancel') {
-      console.log(chalk.dim('\nCancelled. No changes made.'));
-      return;
+      if (smartMergeAction === 'explore') {
+        // Individual exploration for each customized command
+        console.log(chalk.cyan('\n  Exploring customized commands...\n'));
+
+        for (const cmd of customizedCommands) {
+          const assetInfo = assetsNeedingMerge.commands.find(a => a.name === cmd);
+          const local = getLocalAsset('commands', cmd, process.cwd());
+          const template = getTemplateAsset('commands', cmd);
+
+          // Show merge explanation
+          console.log(chalk.bold(`\n  ┌${'─'.repeat(60)}┐`));
+          console.log(chalk.bold(`  │ /${cmd.padEnd(58)} │`));
+          console.log(chalk.bold(`  └${'─'.repeat(60)}┘`));
+
+          const explanation = generateMergeExplanation(
+            'commands',
+            cmd,
+            assetInfo.comparison,
+            local?.content,
+            template?.content
+          );
+
+          // Display condensed explanation
+          console.log(chalk.dim('\n  ' + explanation.split('\n').slice(0, 15).join('\n  ')));
+
+          const { decision } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'decision',
+              message: `What would you like to do with /${cmd}?`,
+              choices: [
+                { name: 'Skip - Keep your customized version', value: 'skip' },
+                { name: 'Backup & Replace - Save yours, use new version', value: 'backup' },
+                { name: 'Replace - Use new version (no backup)', value: 'replace' },
+                { name: 'Show full diff', value: 'diff' },
+              ],
+            },
+          ]);
+
+          if (decision === 'diff') {
+            // Show full diff
+            console.log(chalk.dim('\n--- Your Version ---'));
+            console.log(local?.content?.slice(0, 500) + (local?.content?.length > 500 ? '\n...(truncated)' : ''));
+            console.log(chalk.dim('\n--- Update Version ---'));
+            console.log(template?.content?.slice(0, 500) + (template?.content?.length > 500 ? '\n...(truncated)' : ''));
+
+            // Re-prompt after showing diff
+            const { finalDecision } = await inquirer.prompt([
+              {
+                type: 'list',
+                name: 'finalDecision',
+                message: `Final decision for /${cmd}?`,
+                choices: [
+                  { name: 'Skip - Keep your version', value: 'skip' },
+                  { name: 'Backup & Replace', value: 'backup' },
+                  { name: 'Replace without backup', value: 'replace' },
+                ],
+              },
+            ]);
+            smartMergeDecisions[cmd] = finalDecision;
+          } else {
+            smartMergeDecisions[cmd] = decision;
+          }
+        }
+      } else if (smartMergeAction === 'skip-customized') {
+        // Mark all customized commands as skip
+        for (const cmd of customizedCommands) {
+          smartMergeDecisions[cmd] = 'skip';
+        }
+        console.log(chalk.green(`\n  ✓ Will preserve ${customizedCommands.length} customized command(s)`));
+      } else if (smartMergeAction === 'replace-all') {
+        // Mark all customized commands as replace with backup
+        for (const cmd of customizedCommands) {
+          smartMergeDecisions[cmd] = 'backup';
+        }
+        console.log(chalk.yellow(`\n  ⚠ Will backup and replace ${customizedCommands.length} customized command(s)`));
+      }
+
+      // Remove customized commands from the standard overwrite flow
+      // (they're handled by smart merge decisions)
+      const nonCustomizedToOverwrite = commandsToOverwrite.filter(c => !customizedCommands.includes(c));
+
+      if (nonCustomizedToOverwrite.length > 0) {
+        console.log(chalk.yellow.bold('\n  ⚠ The following non-customized commands also exist:'));
+        for (const cmd of nonCustomizedToOverwrite) {
+          console.log(chalk.yellow(`    • /${cmd}`));
+        }
+      }
     }
 
-    overwrite = overwriteChoice === 'overwrite' || overwriteChoice === 'backup';
-    const createBackups = overwriteChoice === 'backup';
-
-    if (!overwrite) {
-      // Filter out existing commands (keep only new ones + required)
-      const filtered = finalCommands.filter((c) => !existingCmdNames.includes(c) || requiredCommands.includes(c));
-      finalCommands.length = 0;
-      finalCommands.push(...filtered);
-      console.log(chalk.green(`\n  ✓ Will install ${finalCommands.length} new command(s), preserving ${commandsToOverwrite.length} existing`));
-    } else if (createBackups) {
-      console.log(chalk.cyan(`\n  ✓ Will backup and overwrite ${commandsToOverwrite.length} existing command(s)`));
-    } else {
-      console.log(chalk.yellow(`\n  ⚠ Will overwrite ${commandsToOverwrite.length} existing command(s)`));
+    // Standard overwrite prompt for non-customized commands
+    const remainingToOverwrite = commandsToOverwrite.filter(c => !smartMergeDecisions[c]);
+
+    if (remainingToOverwrite.length > 0) {
+      if (!customizedCommands || customizedCommands.length === 0) {
+        console.log(chalk.yellow.bold('  ⚠ The following commands already exist:'));
+        for (const cmd of remainingToOverwrite) {
+          console.log(chalk.yellow(`    • /${cmd}`));
+        }
+      }
+      console.log('');
+
+      const { overwriteChoice } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'overwriteChoice',
+          message: 'How would you like to handle these existing commands?',
+          choices: [
+            { name: 'Skip existing - only install new commands (recommended)', value: 'skip' },
+            { name: 'Overwrite with backup - save existing to .claude/backups/ first', value: 'backup' },
+            { name: 'Overwrite all - replace existing (no backup)', value: 'overwrite' },
+            { name: 'Cancel installation', value: 'cancel' },
+          ],
+        },
+      ]);
+
+      if (overwriteChoice === 'cancel') {
+        console.log(chalk.dim('\nCancelled. No changes made.'));
+        return;
+      }
+
+      overwrite = overwriteChoice === 'overwrite' || overwriteChoice === 'backup';
+
+      // Apply decision to remaining commands
+      for (const cmd of remainingToOverwrite) {
+        smartMergeDecisions[cmd] = overwriteChoice === 'skip' ? 'skip' : (overwriteChoice === 'backup' ? 'backup' : 'replace');
+      }
+
+      if (!overwrite) {
+        // Filter out skipped commands
+        const skippedCommands = Object.entries(smartMergeDecisions)
+          .filter(([, decision]) => decision === 'skip')
+          .map(([cmd]) => cmd);
+        const filtered = finalCommands.filter((c) => !skippedCommands.includes(c) || requiredCommands.includes(c));
+        finalCommands.length = 0;
+        finalCommands.push(...filtered);
+        console.log(chalk.green(`\n  ✓ Will install ${finalCommands.length} new command(s), preserving ${skippedCommands.length} existing`));
+      } else if (overwriteChoice === 'backup') {
+        console.log(chalk.cyan(`\n  ✓ Will backup and overwrite ${remainingToOverwrite.length} existing command(s)`));
+      } else {
+        console.log(chalk.yellow(`\n  ⚠ Will overwrite ${remainingToOverwrite.length} existing command(s)`));
+      }
+    } else if (Object.keys(smartMergeDecisions).length > 0) {
+      // All commands handled by smart merge
+      const skippedCommands = Object.entries(smartMergeDecisions)
+        .filter(([, decision]) => decision === 'skip')
+        .map(([cmd]) => cmd);
+
+      if (skippedCommands.length > 0) {
+        const filtered = finalCommands.filter((c) => !skippedCommands.includes(c) || requiredCommands.includes(c));
+        finalCommands.length = 0;
+        finalCommands.push(...filtered);
+      }
     }
   }
 
   // Track if we should create backups (set outside the if block for use later)
+  // Now also considers smart merge decisions
   const createBackups = options.backup || (typeof overwrite !== 'undefined' && commandsToOverwrite.length > 0 && !options.force);
   let backedUpFiles = [];
 
+  // Helper to check if a command should be backed up based on smart merge decisions
+  const shouldBackupCommand = (cmdName) => {
+    if (smartMergeDecisions[cmdName]) {
+      return smartMergeDecisions[cmdName] === 'backup';
+    }
+    return createBackups;
+  };
+
+  // Helper to check if a command should be skipped based on smart merge decisions
+  const shouldSkipCommand = (cmdName) => {
+    if (smartMergeDecisions[cmdName]) {
+      return smartMergeDecisions[cmdName] === 'skip';
+    }
+    return false;
+  };
+
   // Step 7: Install commands
   console.log(chalk.bold('Step 6: Installing slash commands\n'));
 
@@ -1916,6 +2157,11 @@ export async function runInit(options = {}) {
 
   for (const cmdName of finalCommands) {
     try {
+      // Skip commands that were marked to skip in smart merge
+      if (shouldSkipCommand(cmdName)) {
+        continue;
+      }
+
       const cmdPath = join(commandsDir, `${cmdName}.md`);
 
       let content;
@@ -1938,8 +2184,8 @@ export async function runInit(options = {}) {
         }
       }
 
-      // Create backup if overwriting existing file
-      if (existsSync(cmdPath) && createBackups) {
+      // Create backup if overwriting existing file (respects smart merge decisions)
+      if (existsSync(cmdPath) && shouldBackupCommand(cmdName)) {
         const backupPath = createBackup(cmdPath);
         if (backupPath) {
           backedUpFiles.push({ original: cmdPath, backup: backupPath });
@@ -1960,6 +2206,45 @@ export async function runInit(options = {}) {
     console.log(chalk.cyan(`\n  📁 Backed up ${backedUpFiles.length} file(s) to .claude/backups/`));
   }
 
+  // Step 6b: Deploy feature-specific hooks
+  const deployedHooks = [];
+  const failedHooks = [];
+
+  if (featureHooks.length > 0) {
+    console.log(chalk.bold('\nStep 6b: Deploying feature hooks\n'));
+
+    for (const hookName of featureHooks) {
+      try {
+        const hookPath = join(hooksDir, `${hookName}.js`);
+
+        // Skip if already exists
+        if (existsSync(hookPath)) {
+          console.log(chalk.blue(`  ○ hooks/${hookName}.js exists (preserved)`));
+          continue;
+        }
+
+        // Try to load from templates/hooks/ folder
+        const templatePath = join(__dirname, '..', '..', 'templates', 'hooks', `${hookName}.template.js`);
+        if (existsSync(templatePath)) {
+          const hookContent = readFileSync(templatePath, 'utf8');
+          writeFileSync(hookPath, hookContent, 'utf8');
+          deployedHooks.push(hookName);
+          console.log(chalk.green(`  ✓ Created hooks/${hookName}.js`));
+        } else {
+          failedHooks.push({ name: hookName, error: 'No template found' });
+          console.log(chalk.yellow(`  ⚠ Skipped hooks/${hookName}.js (no template)`));
+        }
+      } catch (error) {
+        failedHooks.push({ name: hookName, error: error.message });
+        console.log(chalk.red(`  ✗ Failed: hooks/${hookName}.js - ${error.message}`));
+      }
+    }
+
+    if (deployedHooks.length > 0) {
+      console.log(chalk.green(`\n  ✓ Deployed ${deployedHooks.length} feature hook(s)`));
+    }
+  }
+
   // Step 7: Generate INDEX.md
   const indexPath = join(commandsDir, 'INDEX.md');
   const indexContent = generateIndexFile(installed, projectName);
@@ -2087,6 +2372,15 @@ export async function runInit(options = {}) {
     },
     // Track which features need post-install configuration
     _pendingConfiguration: featuresRequiringConfig.map((f) => f.name),
+    // Track what was deployed for verification
+    _deployment: {
+      commands: installed,
+      featureCommands: featureCommands.filter(c => installed.includes(c)),
+      hooks: deployedHooks,
+      featureHooks: featureHooks,
+      enabledFeatures: selectedFeatures,
+      timestamp: new Date().toISOString(),
+    },
   };
 
   if (!existsSync(techStackPath)) {

package/src/commands/test-setup.js

@@ -243,8 +243,8 @@ export async function runTestSetup(options) {
         console.log(chalk.dim(`  export ${passwordVar}="your_password"`));
       }
     } else if (credentialSource === 'config') {
-      showWarning('Credentials will be stored in .gtask/testing.json');
-      console.log(chalk.dim('This file will be added to .gitignore'));
+      showWarning('Storing credentials in config is not recommended for security.');
+      console.log(chalk.dim('Consider using environment variables instead.'));
       console.log('');
 
       const { username, password } = await inquirer.prompt([
@@ -398,9 +398,9 @@ export async function runTestSetup(options) {
 
   const testingConfig = createTestingConfig(config);
 
-  // Save main config
+  // Save main config to tech-stack.json
   const configPath = saveTestingConfig(testingConfig);
-  spinner.text = 'Saved testing.json';
+  spinner.text = 'Saved testing config to tech-stack.json';
 
   // Save testing rules markdown
   const { generateRules } = await inquirer.prompt([
@@ -415,7 +415,7 @@ export async function runTestSetup(options) {
   let rulesPath = null;
   if (generateRules) {
     rulesPath = saveTestingRules(testingConfig);
-    spinner.text = 'Saved TESTING_RULES.md';
+    spinner.text = 'Saved TESTING_RULES.md to .claude/task-lists/';
   }
 
   spinner.succeed('Configuration files created');
@@ -427,7 +427,8 @@ export async function runTestSetup(options) {
     `Credentials: ${CREDENTIAL_SOURCES[config.credentialSource].name}`,
     `Playwright: ${config.playwrightEnabled ? 'Enabled' : 'Disabled'}`,
     '',
-    `Config: ${configPath}`,
+    `Config saved to: ${configPath}`,
+    'Testing config is now stored in tech-stack.json under the "testing" section.',
   ];
 
   if (rulesPath) {