claude-cli-advanced-starter-pack 1.0.15 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cli-advanced-starter-pack",
-  "version": "1.0.15",
+  "version": "1.1.0",
   "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

@@ -4,6 +4,8 @@
 
 import chalk from 'chalk';
 import inquirer from 'inquirer';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
 import { runSetup } from '../commands/setup.js';
 import { runCreate } from '../commands/create.js';
 import { runList } from '../commands/list.js';
@@ -22,6 +24,55 @@ import { hasTestingConfig } from '../testing/config.js';
 import { showHelp } from '../commands/help.js';
 import { hasValidConfig, getVersion, loadTechStack, saveTechStack } from '../utils.js';
 
+/**
+ * Get bypass permissions status from settings.json
+ */
+function getBypassPermissionsStatus() {
+  const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+  if (!existsSync(settingsPath)) {
+    return false;
+  }
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    return settings.permissions?.defaultMode === 'bypassPermissions';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Toggle bypass permissions in settings.json
+ */
+function toggleBypassPermissions() {
+  const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+  let settings = {};
+
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.permissions) {
+    settings.permissions = {};
+  }
+
+  const currentMode = settings.permissions.defaultMode;
+  const newMode = currentMode === 'bypassPermissions' ? 'acceptEdits' : 'bypassPermissions';
+  settings.permissions.defaultMode = newMode;
+
+  // Ensure directory exists
+  const dir = dirname(settingsPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  return newMode === 'bypassPermissions';
+}
+
 /**
  * ASCII Art Banner
  */
@@ -40,11 +91,22 @@ const BANNER = `
  * Show Project Settings submenu
  */
 export async function showProjectSettingsMenu() {
+  // Get current bypass status for display
+  const bypassEnabled = getBypassPermissionsStatus();
+  const bypassStatus = bypassEnabled ? chalk.green('ON') : chalk.red('OFF');
+  const bypassLine = `   [P] Bypass All Permissions                             [${bypassStatus}]`;
+  const bypassPadding = ' '.repeat(79 - bypassLine.replace(/\x1B\[[0-9;]*m/g, '').length - 1);
+
   console.log('');
   console.log(chalk.cyan('╔═══════════════════════════════════════════════════════════════════════════════╗'));
   console.log(chalk.cyan('║') + chalk.bold('                           PROJECT CONFIGURATION                               ') + chalk.cyan('║'));
   console.log(chalk.cyan('╠═══════════════════════════════════════════════════════════════════════════════╣'));
   console.log(chalk.cyan('║') + '                                                                               ' + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + bypassLine + bypassPadding + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.dim('       └─ Toggle auto-approve all tool calls (use with caution)               ') + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + '                                                                               ' + chalk.cyan('║'));
+  console.log(chalk.cyan('╠───────────────────────────────────────────────────────────────────────────────╣'));
+  console.log(chalk.cyan('║') + '                                                                               ' + chalk.cyan('║'));
   console.log(chalk.cyan('║') + '   [1] GitHub Project Board                                                    ' + chalk.cyan('║'));
   console.log(chalk.cyan('║') + chalk.dim('       └─ Connect to GitHub Projects v2 for issue tracking                     ') + chalk.cyan('║'));
   console.log(chalk.cyan('║') + '                                                                               ' + chalk.cyan('║'));
@@ -71,6 +133,8 @@ export async function showProjectSettingsMenu() {
       name: 'settingsAction',
       message: 'Select a configuration area:',
       choices: [
+        { name: `P. Bypass All Permissions [${bypassEnabled ? 'ON' : 'OFF'}]`, value: 'bypass' },
+        new inquirer.Separator(),
         { name: '1. GitHub Project Board', value: 'github' },
         { name: '2. Deployment Platforms', value: 'deployment' },
         { name: '3. Tunnel Services', value: 'tunnel' },
@@ -86,6 +150,22 @@ export async function showProjectSettingsMenu() {
     return;
   }
 
+  // Handle bypass toggle
+  if (settingsAction === 'bypass') {
+    const newState = toggleBypassPermissions();
+    console.log('');
+    if (newState) {
+      console.log(chalk.green('  ✓ Bypass All Permissions: ON'));
+      console.log(chalk.yellow('    All tool calls will be auto-approved'));
+    } else {
+      console.log(chalk.green('  ✓ Bypass All Permissions: OFF'));
+      console.log(chalk.dim('    Using Accept Edits mode (prompts for Edit/Write/Bash)'));
+    }
+    console.log('');
+    await showProjectSettingsMenu();
+    return;
+  }
+
   // Load current tech-stack.json
   const techStack = loadTechStack();
 

package/src/commands/init.js

@@ -42,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: ['context-guardian'],  // Only include hooks with templates
+    hooks: ['context-guardian', 'token-budget-loader', 'tool-output-cacher'],
     default: false,
     requiresPostConfig: false,
   },
@@ -51,10 +51,10 @@ const OPTIONAL_FEATURES = [
     label: 'Happy Engineering Integration',
     description: 'Integration with Happy Coder mobile app for remote session control, checkpoint management, and mobile-optimized responses.',
     commands: ['happy-start'],
-    hooks: ['happy-checkpoint-manager'],  // Only include hooks with templates
+    hooks: ['happy-checkpoint-manager', 'happy-title-generator', 'happy-mode-detector', 'context-injector'],
     default: false,
     requiresPostConfig: true,
-    npmPackage: 'happy-coder',  // Optional npm package to install
+    npmPackage: 'happy-coder',
     npmInstallPrompt: 'Install Happy Coder CLI globally? (npm i -g happy-coder)',
   },
   {

package/src/data/releases.json

@@ -1,5 +1,75 @@
 {
   "releases": [
+    {
+      "version": "1.1.0",
+      "date": "2026-01-30",
+      "summary": "Feature: Phase 1 of 85 Recommendations - 5 New Hook Templates",
+      "highlights": [
+        "Added tool-output-cacher.template.js - Caches large outputs, saves ~500 tokens per output",
+        "Added token-budget-loader.template.js - Pre-calculates daily budget, ~5K tokens/session savings",
+        "Added happy-title-generator.template.js - Auto-generates session titles with issue numbers",
+        "Added happy-mode-detector.template.js - Detects Happy daemon environment",
+        "Added context-injector.template.js - Injects prior session context for continuity",
+        "All hooks now configurable via .claude/config/hooks-config.json",
+        "Updated tokenManagement feature to include token-budget-loader and tool-output-cacher",
+        "Updated happyMode feature to include all Happy-related hooks"
+      ],
+      "newFeatures": {
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": [
+          {
+            "name": "tool-output-cacher",
+            "description": "Caches large tool outputs to reduce context consumption"
+          },
+          {
+            "name": "token-budget-loader",
+            "description": "Pre-calculates daily token budget at session start"
+          },
+          {
+            "name": "happy-title-generator",
+            "description": "Auto-generates session titles for Happy daemon"
+          },
+          {
+            "name": "happy-mode-detector",
+            "description": "Detects Happy daemon environment and enables mobile mode"
+          },
+          {
+            "name": "context-injector",
+            "description": "Injects prior session context for seamless resumption"
+          }
+        ],
+        "other": []
+      },
+      "breaking": [],
+      "deprecated": []
+    },
+    {
+      "version": "1.0.16",
+      "date": "2026-01-30",
+      "summary": "Feature: Bypass All Permissions toggle in Project Settings menu",
+      "highlights": [
+        "Quick toggle for Bypass All Permissions mode from /menu → Project Settings",
+        "Live status display shows current state (ON/OFF)",
+        "Toggles between bypassPermissions and acceptEdits modes",
+        "Updates .claude/settings.json directly"
+      ],
+      "newFeatures": {
+        "commands": [],
+        "agents": [],
+        "skills": [],
+        "hooks": [],
+        "other": [
+          {
+            "name": "bypass-permissions-toggle",
+            "description": "Quick toggle in Project Settings to enable/disable auto-approve mode"
+          }
+        ]
+      },
+      "breaking": [],
+      "deprecated": []
+    },
     {
       "version": "1.0.15",
       "date": "2026-01-30",

package/templates/hooks/context-injector.template.js

@@ -0,0 +1,261 @@
+/**
+ * Context Injector Hook
+ *
+ * Injects prior session context for seamless resumption.
+ * Loads checkpoints, recent progress, and active features.
+ * Enables continuity across multi-day projects.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  recent_completed_tasks: 3,     // Number of completed tasks to show
+  next_pending_tasks: 2,         // Number of pending tasks to show
+  active_features_limit: 3,      // Number of active features to show
+  recent_agents_limit: 5,        // Number of recent agents to show
+  max_checkpoint_age_hours: 48,  // Ignore checkpoints older than this
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const CHECKPOINT_PATH = path.join(process.cwd(), '.claude', 'checkpoints', 'latest.json');
+const FEATURE_TRACKING_PATH = path.join(process.cwd(), '.claude', 'config', 'feature-tracking.json');
+const AGENT_LOG_PATH = path.join(process.cwd(), '.claude', 'logs', 'agent-activity.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.context-injected');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.context_injector || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Check if we've already injected context this session
+ */
+function hasInjectedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const timestamp = parseInt(content, 10);
+      // Session valid for 4 hours
+      if (Date.now() - timestamp < 4 * 60 * 60 * 1000) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Continue with injection
+  }
+  return false;
+}
+
+/**
+ * Mark session as injected
+ */
+function markSessionInjected() {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, Date.now().toString(), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Load latest checkpoint
+ */
+function loadCheckpoint(config) {
+  try {
+    if (!fs.existsSync(CHECKPOINT_PATH)) {
+      return null;
+    }
+
+    const checkpoint = JSON.parse(fs.readFileSync(CHECKPOINT_PATH, 'utf8'));
+
+    // Check age
+    if (checkpoint.created_at) {
+      const age = Date.now() - new Date(checkpoint.created_at).getTime();
+      const maxAge = config.max_checkpoint_age_hours * 60 * 60 * 1000;
+      if (age > maxAge) {
+        return null; // Checkpoint too old
+      }
+    }
+
+    return checkpoint;
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Load feature tracking
+ */
+function loadFeatureTracking() {
+  try {
+    if (fs.existsSync(FEATURE_TRACKING_PATH)) {
+      return JSON.parse(fs.readFileSync(FEATURE_TRACKING_PATH, 'utf8'));
+    }
+  } catch (e) {
+    // No feature tracking
+  }
+  return null;
+}
+
+/**
+ * Load recent agent activity
+ */
+function loadAgentActivity(config) {
+  try {
+    if (fs.existsSync(AGENT_LOG_PATH)) {
+      const activity = JSON.parse(fs.readFileSync(AGENT_LOG_PATH, 'utf8'));
+      // Return most recent agents
+      if (Array.isArray(activity)) {
+        return activity.slice(-config.recent_agents_limit);
+      }
+    }
+  } catch (e) {
+    // No agent activity
+  }
+  return [];
+}
+
+/**
+ * Format task list for display
+ */
+function formatTaskList(tasks, limit, status) {
+  if (!tasks || !Array.isArray(tasks)) return '';
+
+  const filtered = tasks.filter(t => t.status === status).slice(0, limit);
+  if (filtered.length === 0) return '';
+
+  return filtered.map(t => `  - ${t.title || t.name || 'Unknown task'}`).join('\n');
+}
+
+/**
+ * Format feature list for display
+ */
+function formatFeatureList(features, limit) {
+  if (!features || !Array.isArray(features)) return '';
+
+  const active = features.filter(f => f.status === 'in_progress').slice(0, limit);
+  if (active.length === 0) return '';
+
+  return active.map(f => `  - ${f.name}: ${f.progress || 0}%`).join('\n');
+}
+
+/**
+ * Format agent list for display
+ */
+function formatAgentList(agents) {
+  if (!agents || agents.length === 0) return '';
+
+  return agents.map(a => {
+    const name = a.name || a.type || 'agent';
+    const status = a.success ? 'completed' : 'failed';
+    return `  - ${name}: ${status}`;
+  }).join('\n');
+}
+
+/**
+ * Build context message
+ */
+function buildContextMessage(checkpoint, features, agents, config) {
+  const sections = [];
+
+  // Add checkpoint progress
+  if (checkpoint) {
+    const completed = formatTaskList(checkpoint.tasks, config.recent_completed_tasks, 'completed');
+    const pending = formatTaskList(checkpoint.tasks, config.next_pending_tasks, 'pending');
+
+    if (completed) {
+      sections.push(`**Recent Progress:**\n${completed}`);
+    }
+    if (pending) {
+      sections.push(`**Next Tasks:**\n${pending}`);
+    }
+    if (checkpoint.current_phase) {
+      sections.push(`**Current Phase:** ${checkpoint.current_phase}`);
+    }
+  }
+
+  // Add active features
+  if (features) {
+    const featureList = formatFeatureList(features.features || features, config.active_features_limit);
+    if (featureList) {
+      sections.push(`**Active Features:**\n${featureList}`);
+    }
+  }
+
+  // Add recent agents
+  if (agents && agents.length > 0) {
+    const agentList = formatAgentList(agents);
+    if (agentList) {
+      sections.push(`**Recent Agents:**\n${agentList}`);
+    }
+  }
+
+  return sections.join('\n\n');
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function contextInjector(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Check if already injected this session
+    if (hasInjectedThisSession()) {
+      return approve();
+    }
+
+    // Mark session as injected
+    markSessionInjected();
+
+    const config = loadConfig();
+
+    // Load context sources
+    const checkpoint = loadCheckpoint(config);
+    const features = loadFeatureTracking();
+    const agents = loadAgentActivity(config);
+
+    // Check if we have any context to inject
+    if (!checkpoint && !features && agents.length === 0) {
+      console.log('[context-injector] No prior context found');
+      return approve();
+    }
+
+    // Build context message
+    const message = buildContextMessage(checkpoint, features, agents, config);
+
+    if (message) {
+      console.log('[context-injector] Session context loaded:');
+      console.log('---');
+      console.log(message);
+      console.log('---');
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[context-injector] Error: ${error.message}`);
+    return approve();
+  }
+};

package/templates/hooks/happy-mode-detector.template.js

@@ -0,0 +1,214 @@
+/**
+ * Happy Mode Detector Hook
+ *
+ * Auto-detects Happy daemon environment and enables mobile-optimized mode.
+ * Sets appropriate verbosity and response formatting for mobile clients.
+ * Supports multiple detection methods: env var, daemon state, manual config.
+ *
+ * Event: UserPromptSubmit (runs once per session)
+ *
+ * Configuration: Reads from .claude/config/hooks-config.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Default configuration (can be overridden by hooks-config.json)
+const DEFAULT_CONFIG = {
+  enabled: false,                     // Manual override
+  auto_detect: true,                  // Attempt auto-detection
+  verbosity: 'condensed',             // 'verbose', 'condensed', 'compact'
+  show_file_stats: true,              // Show file operation statistics
+  max_grep_results: 5,                // Limit grep results for mobile
+  checkpoint_interval_minutes: 10,    // Auto-checkpoint frequency
+};
+
+// Paths
+const CONFIG_PATH = path.join(process.cwd(), '.claude', 'config', 'hooks-config.json');
+const HAPPY_MODE_PATH = path.join(process.cwd(), '.claude', 'config', 'happy-mode.json');
+const HAPPY_STATE_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.happy', 'daemon.state.json');
+const SESSION_MARKER = path.join(process.cwd(), '.claude', 'config', '.happy-detected');
+
+/**
+ * Load configuration with defaults
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      return { ...DEFAULT_CONFIG, ...(config.happy_mode || {}) };
+    }
+  } catch (e) {
+    // Use defaults on error
+  }
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Check if we've already detected Happy mode this session
+ */
+function hasDetectedThisSession() {
+  try {
+    if (fs.existsSync(SESSION_MARKER)) {
+      const content = fs.readFileSync(SESSION_MARKER, 'utf8');
+      const data = JSON.parse(content);
+      // Session valid for 4 hours
+      if (Date.now() - data.timestamp < 4 * 60 * 60 * 1000) {
+        return data;
+      }
+    }
+  } catch (e) {
+    // Continue with detection
+  }
+  return null;
+}
+
+/**
+ * Mark session as detected
+ */
+function markSessionDetected(result) {
+  try {
+    const dir = path.dirname(SESSION_MARKER);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(SESSION_MARKER, JSON.stringify({
+      timestamp: Date.now(),
+      ...result,
+    }, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Detect Happy mode via environment variable
+ */
+function detectViaEnvVar() {
+  return process.env.HAPPY_SESSION === 'true';
+}
+
+/**
+ * Detect Happy mode via daemon state file
+ */
+function detectViaDaemonState() {
+  try {
+    if (fs.existsSync(HAPPY_STATE_PATH)) {
+      const state = JSON.parse(fs.readFileSync(HAPPY_STATE_PATH, 'utf8'));
+      // Check if daemon is running and has active session
+      if (state.running && state.current_session) {
+        return true;
+      }
+    }
+  } catch (e) {
+    // Daemon not running or state invalid
+  }
+  return false;
+}
+
+/**
+ * Detect Happy mode via manual configuration
+ */
+function detectViaManualConfig() {
+  try {
+    if (fs.existsSync(HAPPY_MODE_PATH)) {
+      const config = JSON.parse(fs.readFileSync(HAPPY_MODE_PATH, 'utf8'));
+      return config.enabled === true;
+    }
+  } catch (e) {
+    // No manual config
+  }
+  return false;
+}
+
+/**
+ * Get detection method description
+ */
+function getDetectionMethod(envVar, daemon, manual) {
+  if (manual) return 'manual_config';
+  if (envVar) return 'env_var';
+  if (daemon) return 'daemon_state';
+  return 'none';
+}
+
+/**
+ * Save Happy mode state for other hooks to use
+ */
+function saveHappyModeState(result) {
+  try {
+    const dir = path.dirname(HAPPY_MODE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(HAPPY_MODE_PATH, JSON.stringify(result, null, 2), 'utf8');
+  } catch (e) {
+    // Silent failure
+  }
+}
+
+/**
+ * Main hook handler
+ */
+module.exports = async function happyModeDetector(context) {
+  // Always continue - never block
+  const approve = () => ({ continue: true });
+
+  try {
+    // Check if already detected this session
+    const cached = hasDetectedThisSession();
+    if (cached) {
+      return approve();
+    }
+
+    const config = loadConfig();
+
+    // Skip detection if auto-detect is disabled
+    if (!config.auto_detect) {
+      const result = {
+        happy_mode: config.enabled,
+        detection_method: config.enabled ? 'manual_override' : 'disabled',
+        config: config,
+      };
+      markSessionDetected(result);
+      return approve();
+    }
+
+    // Try all detection methods
+    const viaEnvVar = detectViaEnvVar();
+    const viaDaemon = detectViaDaemonState();
+    const viaManual = detectViaManualConfig();
+
+    const isHappyMode = viaEnvVar || viaDaemon || viaManual;
+    const detectionMethod = getDetectionMethod(viaEnvVar, viaDaemon, viaManual);
+
+    // Build result object
+    const result = {
+      happy_mode: isHappyMode,
+      detection_method: detectionMethod,
+      detected_at: new Date().toISOString(),
+      config: {
+        verbosity: config.verbosity,
+        show_file_stats: config.show_file_stats,
+        max_grep_results: config.max_grep_results,
+        checkpoint_interval_minutes: config.checkpoint_interval_minutes,
+      },
+    };
+
+    // Save state for other hooks
+    saveHappyModeState(result);
+    markSessionDetected(result);
+
+    // Log detection result
+    if (isHappyMode) {
+      console.log(`[happy-mode-detector] Happy mode ENABLED (via ${detectionMethod})`);
+      console.log(`[happy-mode-detector] Verbosity: ${config.verbosity}`);
+    } else {
+      console.log('[happy-mode-detector] Happy mode not detected');
+    }
+
+    return approve();
+  } catch (error) {
+    console.error(`[happy-mode-detector] Error: ${error.message}`);
+    return approve();
+  }
+};