claude-code-templates 1.14.14 → 1.14.16

package/README.md

@@ -51,14 +51,14 @@ npx claude-code-templates@latest --health-check
 
 ## 📖 Documentation
 
-**[📚 Complete Documentation](https://aitmpl.com/docu/)** - Comprehensive guides, examples, and API reference
+**[📚 Complete Documentation](https://docs.aitmpl.com/)** - Comprehensive guides, examples, and API reference
 
 Quick links:
-- [Getting Started](https://aitmpl.com/docu/docs/intro) - Installation and first steps
-- [Project Setup](https://aitmpl.com/docu/docs/project-setup/interactive-setup) - Configure your projects
-- [Analytics Dashboard](https://aitmpl.com/docu/docs/analytics/overview) - Real-time monitoring
-- [Individual Components](https://aitmpl.com/docu/docs/components/overview) - Agents, Commands, MCPs
-- [CLI Options](https://aitmpl.com/docu/docs/cli-options) - All available commands
+- [Getting Started](https://docs.aitmpl.com/docs/intro) - Installation and first steps
+- [Project Setup](https://docs.aitmpl.com/docs/project-setup/interactive-setup) - Configure your projects
+- [Analytics Dashboard](https://docs.aitmpl.com/docs/analytics/overview) - Real-time monitoring
+- [Individual Components](https://docs.aitmpl.com/docs/components/overview) - Agents, Commands, MCPs
+- [CLI Options](https://docs.aitmpl.com/docs/cli-options) - All available commands
 
 ## 🤝 Contributing
 
@@ -71,7 +71,7 @@ MIT License - see the [LICENSE](LICENSE) file for details.
 ## 🔗 Links
 
 - **🌐 Browse Components**: [aitmpl.com](https://aitmpl.com)
-- **📚 Documentation**: [aitmpl.com/docu](https://aitmpl.com/docu)
+- **📚 Documentation**: [docs.aitmpl.com](https://docs.aitmpl.com)
 - **🐛 Issues**: [GitHub Issues](https://github.com/davila7/claude-code-templates/issues)
 - **💬 Discussions**: [GitHub Discussions](https://github.com/davila7/claude-code-templates/discussions)
 

package/bin/create-claude-config.js

@@ -55,10 +55,11 @@ program
   .option('--analytics', 'launch real-time Claude Code analytics dashboard')
   .option('--chats, --agents', 'launch Claude Code chats/agents dashboard (opens directly to conversations)')
   .option('--health-check, --health, --check, --verify', 'run comprehensive health check to verify Claude Code setup')
-  .option('--agent <agent>', 'install specific agent component')
-  .option('--command <command>', 'install specific command component')
-  .option('--mcp <mcp>', 'install specific MCP component')
-  .option('--workflow <workflow>', 'install workflow from hash (format: #hash)')
+  .option('--agent <agent>', 'install specific agent component (supports comma-separated values)')
+  .option('--command <command>', 'install specific command component (supports comma-separated values)')
+  .option('--mcp <mcp>', 'install specific MCP component (supports comma-separated values)')
+  .option('--workflow <workflow>', 'install workflow from hash (#hash) OR workflow YAML (base64 encoded) when used with --agent/--command/--mcp')
+  .option('--prompt <prompt>', 'execute the provided prompt in Claude Code after installation')
   .action(async (options) => {
     try {
       await createClaudeConfig(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.14.14",
+  "version": "1.14.16",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {

package/src/health-check.js

@@ -16,7 +16,9 @@ class HealthChecker {
       system: [],
       claudeCode: [],
       project: [],
+      agents: [],
       commands: [],
+      mcps: [],
       hooks: []
     };
     this.totalChecks = 0;
@@ -42,6 +44,14 @@ class HealthChecker {
     await this.checkProjectSetupWithSpinner();
     await this.sleep(3000);
     
+    // Agents check
+    await this.checkAgentsWithSpinner();
+    await this.sleep(3000);
+    
+    // MCP servers check
+    await this.checkMCPServersWithSpinner();
+    await this.sleep(3000);
+    
     // Custom commands check
     await this.checkCustomCommandsWithSpinner();
     await this.sleep(3000);
@@ -165,6 +175,54 @@ class HealthChecker {
     localSettingsSpinner.succeed(`${this.getStatusIcon(localSettingsInfo.status)} Local Settings       │ ${localSettingsInfo.message}`);
   }
 
+  /**
+   * Check agents with spinner and immediate results
+   */
+  async checkAgentsWithSpinner() {
+    console.log(chalk.cyan('\n┌──────────┐'));
+    console.log(chalk.cyan('│  AGENTS  │'));
+    console.log(chalk.cyan('└──────────┘'));
+    
+    // Project agents
+    const projectSpinner = ora('Scanning Project Agents...').start();
+    const projectAgents = this.checkProjectAgents();
+    this.addResult('agents', 'Project Agents', projectAgents.status, projectAgents.message);
+    projectSpinner.succeed(`${this.getStatusIcon(projectAgents.status)} Project Agents      │ ${projectAgents.message}`);
+
+    // Personal agents
+    const personalSpinner = ora('Scanning Personal Agents...').start();
+    const personalAgents = this.checkPersonalAgents();
+    this.addResult('agents', 'Personal Agents', personalAgents.status, personalAgents.message);
+    personalSpinner.succeed(`${this.getStatusIcon(personalAgents.status)} Personal Agents     │ ${personalAgents.message}`);
+
+    // Agent syntax validation
+    const syntaxSpinner = ora('Validating Agent Syntax...').start();
+    const syntaxInfo = this.checkAgentSyntax();
+    this.addResult('agents', 'Agent Syntax', syntaxInfo.status, syntaxInfo.message);
+    syntaxSpinner.succeed(`${this.getStatusIcon(syntaxInfo.status)} Agent Syntax        │ ${syntaxInfo.message}`);
+  }
+
+  /**
+   * Check MCP servers with spinner and immediate results
+   */
+  async checkMCPServersWithSpinner() {
+    console.log(chalk.cyan('\n┌──────────────┐'));
+    console.log(chalk.cyan('│  MCP SERVERS │'));
+    console.log(chalk.cyan('└──────────────┘'));
+    
+    // Project MCP configuration
+    const projectMCPSpinner = ora('Scanning Project MCP Configuration...').start();
+    const projectMCP = this.checkProjectMCPConfiguration();
+    this.addResult('mcps', 'Project MCP Config', projectMCP.status, projectMCP.message);
+    projectMCPSpinner.succeed(`${this.getStatusIcon(projectMCP.status)} Project MCP Config   │ ${projectMCP.message}`);
+
+    // MCP configuration validation
+    const mcpValidationSpinner = ora('Validating MCP Configuration...').start();
+    const mcpValidation = this.checkMCPConfigurationSyntax();
+    this.addResult('mcps', 'MCP Config Syntax', mcpValidation.status, mcpValidation.message);
+    mcpValidationSpinner.succeed(`${this.getStatusIcon(mcpValidation.status)} MCP Config Syntax   │ ${mcpValidation.message}`);
+  }
+
   /**
    * Check custom commands with spinner and immediate results
    */
@@ -552,6 +610,123 @@ class HealthChecker {
     }
   }
 
+  checkProjectMCPConfiguration() {
+    const currentDir = process.cwd();
+    const mcpConfigPath = path.join(currentDir, '.mcp.json');
+    
+    if (fs.existsSync(mcpConfigPath)) {
+      try {
+        const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+        
+        if (mcpConfig.mcpServers && typeof mcpConfig.mcpServers === 'object') {
+          const serverCount = Object.keys(mcpConfig.mcpServers).length;
+          return {
+            status: 'pass',
+            message: `${serverCount} MCP servers configured in .mcp.json`
+          };
+        } else {
+          return {
+            status: 'warn',
+            message: 'No mcpServers found in .mcp.json'
+          };
+        }
+      } catch (error) {
+        return {
+          status: 'fail',
+          message: 'Invalid JSON syntax in .mcp.json'
+        };
+      }
+    } else {
+      return {
+        status: 'warn',
+        message: 'No project MCP configuration found (.mcp.json)'
+      };
+    }
+  }
+
+  checkMCPConfigurationSyntax() {
+    const configPaths = [
+      path.join(process.cwd(), '.mcp.json')
+    ];
+    
+    let totalServers = 0;
+    let validServers = 0;
+    let invalidServers = 0;
+    const issues = [];
+    
+    for (const configPath of configPaths) {
+      if (fs.existsSync(configPath)) {
+        try {
+          const mcpConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          
+          if (mcpConfig.mcpServers && typeof mcpConfig.mcpServers === 'object') {
+            const servers = mcpConfig.mcpServers;
+            
+            for (const [serverName, serverConfig] of Object.entries(servers)) {
+              totalServers++;
+              
+              // Validate server configuration structure
+              if (!serverConfig || typeof serverConfig !== 'object') {
+                invalidServers++;
+                issues.push(`Invalid server config for ${serverName} in ${path.basename(configPath)}`);
+                continue;
+              }
+              
+              // Check required fields
+              if (!serverConfig.command) {
+                invalidServers++;
+                issues.push(`Missing command for ${serverName} in ${path.basename(configPath)}`);
+                continue;
+              }
+              
+              // Optional: Check if args is array when present
+              if (serverConfig.args && !Array.isArray(serverConfig.args)) {
+                invalidServers++;
+                issues.push(`Invalid args format for ${serverName} in ${path.basename(configPath)} (should be array)`);
+                continue;
+              }
+              
+              // Optional: Check if env is object when present
+              if (serverConfig.env && typeof serverConfig.env !== 'object') {
+                invalidServers++;
+                issues.push(`Invalid env format for ${serverName} in ${path.basename(configPath)} (should be object)`);
+                continue;
+              }
+              
+              validServers++;
+            }
+          }
+        } catch (error) {
+          // JSON parsing error already handled in other checks
+        }
+      }
+    }
+    
+    if (totalServers === 0) {
+      return {
+        status: 'warn',
+        message: 'No MCP servers configured'
+      };
+    }
+    
+    if (invalidServers === 0) {
+      return {
+        status: 'pass',
+        message: `All ${totalServers} MCP server configurations are valid`
+      };
+    } else if (validServers > 0) {
+      return {
+        status: 'warn',
+        message: `${validServers}/${totalServers} MCP servers valid, ${invalidServers} issues found`
+      };
+    } else {
+      return {
+        status: 'fail',
+        message: `All ${totalServers} MCP server configurations have issues`
+      };
+    }
+  }
+
   checkProjectCommands() {
     const currentDir = process.cwd();
     const commandsDir = path.join(currentDir, '.claude', 'commands');
@@ -625,6 +800,129 @@ class HealthChecker {
     }
   }
 
+  checkProjectAgents() {
+    const currentDir = process.cwd();
+    const agentsDir = path.join(currentDir, '.claude', 'agents');
+    
+    if (fs.existsSync(agentsDir)) {
+      const agents = this.countAgentsRecursively(agentsDir);
+      return {
+        status: 'pass',
+        message: `${agents} agents found in .claude/agents/`
+      };
+    } else {
+      return {
+        status: 'warn',
+        message: 'No project agents directory found'
+      };
+    }
+  }
+
+  checkPersonalAgents() {
+    const homeDir = os.homedir();
+    const agentsDir = path.join(homeDir, '.claude', 'agents');
+    
+    if (fs.existsSync(agentsDir)) {
+      const agents = this.countAgentsRecursively(agentsDir);
+      return {
+        status: 'pass',
+        message: `${agents} agents found in ~/.claude/agents/`
+      };
+    } else {
+      return {
+        status: 'warn',
+        message: 'No personal agents directory found'
+      };
+    }
+  }
+
+  countAgentsRecursively(dir) {
+    let count = 0;
+    try {
+      const items = fs.readdirSync(dir);
+      for (const item of items) {
+        const itemPath = path.join(dir, item);
+        const stat = fs.statSync(itemPath);
+        if (stat.isDirectory()) {
+          count += this.countAgentsRecursively(itemPath);
+        } else if (item.endsWith('.md')) {
+          count++;
+        }
+      }
+    } catch (error) {
+      // Handle permission or access errors
+    }
+    return count;
+  }
+
+  checkAgentSyntax() {
+    const currentDir = process.cwd();
+    const agentsDir = path.join(currentDir, '.claude', 'agents');
+    
+    if (!fs.existsSync(agentsDir)) {
+      return {
+        status: 'warn',
+        message: 'No agents to validate'
+      };
+    }
+    
+    const agents = this.getAgentFilesRecursively(agentsDir);
+    let issuesFound = 0;
+    let agentsChecked = 0;
+    
+    for (const agentPath of agents) {
+      try {
+        const content = fs.readFileSync(agentPath, 'utf8');
+        agentsChecked++;
+        
+        // Check for frontmatter (agent metadata)
+        if (!content.includes('---') || !content.includes('name:') || !content.includes('description:')) {
+          issuesFound++;
+        }
+      } catch (error) {
+        issuesFound++;
+      }
+    }
+    
+    if (agentsChecked === 0) {
+      return {
+        status: 'warn',
+        message: 'No agents to validate'
+      };
+    }
+    
+    if (issuesFound === 0) {
+      return {
+        status: 'pass',
+        message: `All ${agentsChecked} agents have proper syntax`
+      };
+    } else {
+      return {
+        status: 'warn',
+        message: `${issuesFound}/${agentsChecked} agents missing proper frontmatter`
+      };
+    }
+  }
+
+  getAgentFilesRecursively(dir) {
+    let files = [];
+    try {
+      const items = fs.readdirSync(dir);
+      for (const item of items) {
+        const itemPath = path.join(dir, item);
+        const stat = fs.statSync(itemPath);
+        if (stat.isDirectory()) {
+          files = files.concat(this.getAgentFilesRecursively(itemPath));
+        } else if (item.endsWith('.md')) {
+          files.push(itemPath);
+        }
+      }
+    } catch (error) {
+      // Handle permission or access errors
+    }
+    return files;
+  }
+
   checkUserHooks() {
     const homeDir = os.homedir();
     const settingsPath = path.join(homeDir, '.claude', 'settings.json');
@@ -1041,7 +1339,9 @@ class HealthChecker {
       ...this.results.system,
       ...this.results.claudeCode,
       ...this.results.project,
+      ...this.results.agents,
       ...this.results.commands,
+      ...this.results.mcps,
       ...this.results.hooks
     ];
     
@@ -1052,6 +1352,16 @@ class HealthChecker {
           recommendations.push('Consider switching to Zsh for better autocompletion and features');
         } else if (result.check === 'Command Syntax' && result.message.includes('$ARGUMENTS')) {
           recommendations.push('Add $ARGUMENTS placeholder to command files for proper parameter handling');
+        } else if (result.check === 'Agent Syntax' && result.message.includes('frontmatter')) {
+          recommendations.push('Add proper frontmatter (name, description) to agent files');
+        } else if (result.check === 'Project Agents' && result.message.includes('No project agents directory')) {
+          recommendations.push('Create .claude/agents/ directory to organize your custom agents');
+        } else if (result.check === 'Project MCP Config' && result.message.includes('No project MCP configuration')) {
+          recommendations.push('Create .mcp.json file to configure MCP servers for your project');
+        } else if (result.check === 'MCP Config Syntax' && result.message.includes('Invalid JSON')) {
+          recommendations.push('Fix JSON syntax errors in MCP configuration files');
+        } else if (result.check === 'MCP Config Syntax' && result.message.includes('Missing command')) {
+          recommendations.push('Add missing command fields to MCP server configurations');
         } else if (result.check === 'Local Hooks' && result.message.includes('Invalid JSON')) {
           recommendations.push('Fix JSON syntax error in .claude/settings.local.json');
         }

package/src/index.js

@@ -90,23 +90,17 @@ async function showMainMenu() {
 async function createClaudeConfig(options = {}) {
   const targetDir = options.directory || process.cwd();
   
-  // Handle individual component installation
-  if (options.agent) {
-    await installIndividualAgent(options.agent, targetDir, options);
-    return;
-  }
-  
-  if (options.command) {
-    await installIndividualCommand(options.command, targetDir, options);
-    return;
-  }
-  
-  if (options.mcp) {
-    await installIndividualMCP(options.mcp, targetDir, options);
+  // Handle multiple components installation (new approach)
+  if (options.agent || options.command || options.mcp) {
+    // If --workflow is used with components, treat it as YAML
+    if (options.workflow) {
+      options.yaml = options.workflow;
+    }
+    await installMultipleComponents(options, targetDir);
     return;
   }
   
-  // Handle workflow installation
+  // Handle workflow installation (hash-based)
   if (options.workflow) {
     await installWorkflow(options.workflow, targetDir, options);
     return;
@@ -271,7 +265,7 @@ async function createClaudeConfig(options = {}) {
   console.log(chalk.white('  3. Start using Claude Code with: claude'));
   console.log('');
   console.log(chalk.blue('🌐 View all available templates at: https://aitmpl.com/'));
-  console.log(chalk.blue('📖 Read the complete documentation at: https://aitmpl.com/docu/'));
+  console.log(chalk.blue('📖 Read the complete documentation at: https://docs.aitmpl.com/'));
   
   if (config.language !== 'common') {
     console.log(chalk.yellow(`💡 Language-specific features for ${config.language} have been configured`));
@@ -304,6 +298,11 @@ async function createClaudeConfig(options = {}) {
   if (!options.dryRun) {
     await runPostInstallationValidation(targetDir, templateConfig);
   }
+  
+  // Handle prompt execution if provided
+  if (options.prompt) {
+    await handlePromptExecution(options.prompt, targetDir);
+  }
 }
 
 // Individual component installation functions
@@ -597,6 +596,122 @@ async function getAvailableAgentsFromGitHub() {
   }
 }
 
+/**
+ * Install multiple components with optional YAML workflow
+ */
+async function installMultipleComponents(options, targetDir) {
+  console.log(chalk.blue('🔧 Installing multiple components...'));
+  
+  try {
+    const components = {
+      agents: [],
+      commands: [],
+      mcps: []
+    };
+    
+    // Parse comma-separated values for each component type
+    if (options.agent) {
+      const agentsInput = Array.isArray(options.agent) ? options.agent.join(',') : options.agent;
+      components.agents = agentsInput.split(',').map(a => a.trim()).filter(a => a);
+    }
+    
+    if (options.command) {
+      const commandsInput = Array.isArray(options.command) ? options.command.join(',') : options.command;
+      components.commands = commandsInput.split(',').map(c => c.trim()).filter(c => c);
+    }
+    
+    if (options.mcp) {
+      const mcpsInput = Array.isArray(options.mcp) ? options.mcp.join(',') : options.mcp;
+      components.mcps = mcpsInput.split(',').map(m => m.trim()).filter(m => m);
+    }
+    
+    const totalComponents = components.agents.length + components.commands.length + components.mcps.length;
+    
+    if (totalComponents === 0) {
+      console.log(chalk.yellow('⚠️  No components specified to install.'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`📦 Installing ${totalComponents} components:`));
+    console.log(chalk.gray(`   Agents: ${components.agents.length}`));
+    console.log(chalk.gray(`   Commands: ${components.commands.length}`));
+    console.log(chalk.gray(`   MCPs: ${components.mcps.length}`));
+    
+    // Install agents
+    for (const agent of components.agents) {
+      console.log(chalk.gray(`   Installing agent: ${agent}`));
+      await installIndividualAgent(agent, targetDir, { ...options, silent: true });
+    }
+    
+    // Install commands
+    for (const command of components.commands) {
+      console.log(chalk.gray(`   Installing command: ${command}`));
+      await installIndividualCommand(command, targetDir, { ...options, silent: true });
+    }
+    
+    // Install MCPs
+    for (const mcp of components.mcps) {
+      console.log(chalk.gray(`   Installing MCP: ${mcp}`));
+      await installIndividualMCP(mcp, targetDir, { ...options, silent: true });
+    }
+    
+    // Handle YAML workflow if provided
+    if (options.yaml) {
+      console.log(chalk.blue('\n📄 Processing workflow YAML...'));
+      
+      try {
+        // Decode the YAML from base64
+        const yamlContent = Buffer.from(options.yaml, 'base64').toString('utf8');
+        
+        // Parse workflow name from YAML (try to extract from name: field)
+        let workflowName = 'custom-workflow';
+        const nameMatch = yamlContent.match(/name:\s*["']?([^"'\n]+)["']?/);
+        if (nameMatch) {
+          workflowName = nameMatch[1].trim().replace(/[^a-z0-9]/gi, '_').toLowerCase();
+        }
+        
+        // Save YAML to workflows directory
+        const workflowsDir = path.join(targetDir, '.claude', 'workflows');
+        const workflowFile = path.join(workflowsDir, `${workflowName}.yaml`);
+        
+        await fs.ensureDir(workflowsDir);
+        await fs.writeFile(workflowFile, yamlContent, 'utf8');
+        
+        console.log(chalk.green(`✅ Workflow YAML saved: ${path.relative(targetDir, workflowFile)}`));
+        
+      } catch (yamlError) {
+        console.log(chalk.red(`❌ Error processing YAML: ${yamlError.message}`));
+      }
+    }
+    
+    console.log(chalk.green(`\n✅ Successfully installed ${totalComponents} components!`));
+    console.log(chalk.cyan(`📁 Components installed to: .claude/`));
+    
+    if (options.yaml) {
+      console.log(chalk.cyan(`📄 Workflow file created in: .claude/workflows/`));
+      console.log(chalk.cyan(`🚀 Use the workflow file with Claude Code to execute the complete setup`));
+    }
+    
+    // Track installation
+    trackingService.trackDownload('multi-component', 'batch', {
+      installation_type: 'multi-component',
+      agents_count: components.agents.length,
+      commands_count: components.commands.length,
+      mcps_count: components.mcps.length,
+      has_yaml: !!options.yaml,
+      target_directory: path.relative(process.cwd(), targetDir)
+    });
+    
+    // Handle prompt execution if provided
+    if (options.prompt) {
+      await handlePromptExecution(options.prompt, targetDir);
+    }
+    
+  } catch (error) {
+    console.log(chalk.red(`❌ Error installing components: ${error.message}`));
+  }
+}
+
 /**
  * Show available agents organized by category
  */
@@ -673,16 +788,48 @@ async function installWorkflow(workflowHash, targetDir, options) {
     console.log(chalk.gray(`   Commands: ${commands.length}`));
     console.log(chalk.gray(`   MCPs: ${mcps.length}`));
     
-    // Install agents
-    for (const agent of agents) {
-      console.log(chalk.gray(`   Installing agent: ${agent.name}`));
-      await installIndividualAgent(agent.path, targetDir, { ...options, silent: true });
-    }
-    
-    // Install commands
-    for (const command of commands) {
-      console.log(chalk.gray(`   Installing command: ${command.name}`));
-      await installIndividualCommand(command.path, targetDir, { ...options, silent: true });
+    // Install components from workflow data (not from GitHub)
+    if (workflowData.components) {
+      console.log(chalk.blue(`📦 Installing components from workflow package...`));
+      
+      // Install agents
+      if (workflowData.components.agent) {
+        for (const agent of workflowData.components.agent) {
+          console.log(chalk.gray(`   Installing agent: ${agent.name}`));
+          await installComponentFromWorkflow(agent, 'agent', targetDir, options);
+        }
+      }
+      
+      // Install commands  
+      if (workflowData.components.command) {
+        for (const command of workflowData.components.command) {
+          console.log(chalk.gray(`   Installing command: ${command.name}`));
+          await installComponentFromWorkflow(command, 'command', targetDir, options);
+        }
+      }
+      
+      // Install MCPs
+      if (workflowData.components.mcp) {
+        for (const mcp of workflowData.components.mcp) {
+          console.log(chalk.gray(`   Installing MCP: ${mcp.name}`));
+          await installComponentFromWorkflow(mcp, 'mcp', targetDir, options);
+        }
+      }
+    } else {
+      // Fallback to old method for legacy workflows
+      console.log(chalk.yellow(`⚠️  Using legacy component installation method...`));
+      
+      // Install agents
+      for (const agent of agents) {
+        console.log(chalk.gray(`   Installing agent: ${agent.name}`));
+        await installIndividualAgent(agent.path, targetDir, { ...options, silent: true });
+      }
+      
+      // Install commands
+      for (const command of commands) {
+        console.log(chalk.gray(`   Installing command: ${command.name}`));
+        await installIndividualCommand(command.path, targetDir, { ...options, silent: true });
+      }
     }
     
     // Install MCPs
@@ -692,7 +839,15 @@ async function installWorkflow(workflowHash, targetDir, options) {
     }
     
     // Generate and save workflow YAML
-    const yamlContent = generateWorkflowYAML(workflowData);
+    let yamlContent;
+    if (workflowData.yaml) {
+      // Use YAML from workflow package
+      yamlContent = workflowData.yaml;
+    } else {
+      // Generate YAML (legacy)
+      yamlContent = generateWorkflowYAML(workflowData);
+    }
+    
     const workflowsDir = path.join(targetDir, '.claude', 'workflows');
     const workflowFile = path.join(workflowsDir, `${workflowData.name.replace(/[^a-z0-9]/gi, '_').toLowerCase()}.yaml`);
     
@@ -716,6 +871,11 @@ async function installWorkflow(workflowHash, targetDir, options) {
       target_directory: path.relative(process.cwd(), targetDir)
     });
     
+    // Handle prompt execution if provided
+    if (options.prompt) {
+      await handlePromptExecution(options.prompt, targetDir);
+    }
+    
   } catch (error) {
     console.log(chalk.red(`❌ Error installing workflow: ${error.message}`));
     
@@ -728,42 +888,107 @@ async function installWorkflow(workflowHash, targetDir, options) {
   }
 }
 
+/**
+ * Decompress string with Unicode support
+ */
+function decompressString(compressed) {
+  try {
+    // Simple Base64 decoding with Unicode support
+    const decoded = Buffer.from(compressed, 'base64').toString('utf8');
+    // Convert URI encoded characters back
+    return decodeURIComponent(decoded.replace(/(.)/g, function(m, p) {
+      let code = p.charCodeAt(0).toString(16).toUpperCase();
+      if (code.length < 2) code = '0' + code;
+      return '%' + code;
+    }));
+  } catch (error) {
+    throw new Error(`Decompression failed: ${error.message}`);
+  }
+}
+
 /**
  * Fetch workflow data from hash
  * In production, this would fetch from a remote workflow registry
  * For now, we'll simulate this functionality
  */
 async function fetchWorkflowData(hash) {
-  // Simulate fetching workflow data
-  // In production, this would make an API call to a workflow registry
-  // For demo purposes, we'll return a sample workflow if hash matches demo
-  
-  // Demo workflow for testing
-  if (hash === 'demo123' || hash === 'abc123test') {
-    console.log(chalk.green('🎯 Demo workflow found! Using sample configuration...'));
-    return {
-      name: 'Full Stack Development Workflow',
-      description: 'Complete workflow for setting up a full-stack development environment with React frontend, Node.js backend, and security auditing',
-      tags: ['development', 'fullstack', 'react', 'security'],
-      version: '1.0.0',
-      hash: hash,
-      steps: [
-        {
-          type: 'agent',
-          name: 'frontend-developer',
-          path: 'development-team/frontend-developer',
-          category: 'development-team',
-          description: 'Setup React frontend development environment'
-        },
-        {
-          type: 'agent',
-          name: 'backend-architect',
-          path: 'development-team/backend-architect',
-          category: 'development-team',
-          description: 'Configure Node.js backend architecture'
-        },
-        {
-          type: 'command',
+  try {
+    // Check if hash contains encoded data (new format: shortHash_encodedData)
+    if (hash.includes('_')) {
+      console.log(chalk.green('🔓 Decoding workflow from hash...'));
+      
+      const [shortHash, encodedData] = hash.split('_', 2);
+      
+      if (!encodedData) {
+        throw new Error('Invalid hash format: missing encoded data');
+      }
+      
+      // Decode compressed data
+      let decodedData;
+      try {
+        // First try to decompress the data (new compressed format)
+        const decompressedString = decompressString(encodedData);
+        decodedData = JSON.parse(decompressedString);
+      } catch (decompressError) {
+        // Fallback to old Base64 format for compatibility
+        try {
+          const decodedString = decodeURIComponent(escape(atob(encodedData)));
+          decodedData = JSON.parse(decodedString);
+        } catch (base64Error) {
+          throw new Error('Failed to decode workflow data from hash');
+        }
+      }
+      
+      // Validate decoded data structure
+      if (!decodedData.metadata || !decodedData.steps || !decodedData.components) {
+        throw new Error('Invalid workflow data structure in hash');
+      }
+      
+      console.log(chalk.green('✅ Workflow decoded successfully!'));
+      console.log(chalk.gray(`   Short hash: ${shortHash}`));
+      console.log(chalk.gray(`   Timestamp: ${decodedData.timestamp}`));
+      console.log(chalk.gray(`   Version: ${decodedData.version}`));
+      
+      // Convert to expected format
+      return {
+        name: decodedData.metadata.name,
+        description: decodedData.metadata.description,
+        tags: decodedData.metadata.tags || [],
+        version: decodedData.version,
+        hash: shortHash,
+        steps: decodedData.steps,
+        components: decodedData.components,
+        yaml: decodedData.yaml,
+        timestamp: decodedData.timestamp
+      };
+    }
+    
+    // Legacy demo workflows for testing
+    if (hash === 'demo123' || hash === 'abc123test') {
+      console.log(chalk.green('🎯 Demo workflow found! Using sample configuration...'));
+      return {
+        name: 'Full Stack Development Workflow',
+        description: 'Complete workflow for setting up a full-stack development environment with React frontend, Node.js backend, and security auditing',
+        tags: ['development', 'fullstack', 'react', 'security'],
+        version: '1.0.0',
+        hash: hash,
+        steps: [
+          {
+            type: 'agent',
+            name: 'frontend-developer',
+            path: 'development-team/frontend-developer',
+            category: 'development-team',
+            description: 'Setup React frontend development environment'
+          },
+          {
+            type: 'agent',
+            name: 'backend-architect',
+            path: 'development-team/backend-architect',
+            category: 'development-team',
+            description: 'Configure Node.js backend architecture'
+          },
+          {
+            type: 'command',
           name: 'generate-tests',
           path: 'testing/generate-tests',
           category: 'testing',
@@ -787,13 +1012,101 @@ async function fetchWorkflowData(hash) {
     };
   }
   
-  // This is where we would integrate with a workflow registry API
-  // For now, return null to indicate workflow not found for other hashes
-  console.log(chalk.yellow('\n⚠️  Workflow registry not yet implemented.'));
-  console.log(chalk.gray('To test with demo workflow, use hash: demo123'));
-  console.log(chalk.gray('Example: --workflow "#demo123"'));
-  
-  return null;
+    // This is where we would integrate with a workflow registry API
+    // For now, return null to indicate workflow not found for other hashes
+    console.log(chalk.yellow('\n⚠️  Workflow registry not yet implemented.'));
+    console.log(chalk.gray('To test with demo workflow, use hash: demo123'));
+    console.log(chalk.gray('Example: --workflow "#demo123"'));
+    
+    return null;
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Error fetching workflow data: ${error.message}`));
+    return null;
+  }
+}
+
+/**
+ * Install component from workflow package data
+ */
+async function installComponentFromWorkflow(componentData, type, targetDir, options) {
+  try {
+    let targetPath;
+    let fileName = componentData.name;
+    
+    if (type === 'agent') {
+      // Create .claude/agents directory if it doesn't exist
+      const agentsDir = path.join(targetDir, '.claude', 'agents');
+      await fs.ensureDir(agentsDir);
+      
+      // For agents, handle category subdirectories
+      if (componentData.category && componentData.category !== 'general') {
+        const categoryDir = path.join(agentsDir, componentData.category);
+        await fs.ensureDir(categoryDir);
+        targetPath = path.join(categoryDir, `${fileName}.md`);
+      } else {
+        targetPath = path.join(agentsDir, `${fileName}.md`);
+      }
+      
+    } else if (type === 'command') {
+      // Create .claude/commands directory if it doesn't exist
+      const commandsDir = path.join(targetDir, '.claude', 'commands');
+      await fs.ensureDir(commandsDir);
+      targetPath = path.join(commandsDir, `${fileName}.md`);
+      
+    } else if (type === 'mcp') {
+      // For MCPs, merge with existing .mcp.json
+      const targetMcpFile = path.join(targetDir, '.mcp.json');
+      let existingConfig = {};
+      
+      if (await fs.pathExists(targetMcpFile)) {
+        existingConfig = await fs.readJson(targetMcpFile);
+      }
+      
+      // Parse MCP content and merge
+      let mcpConfig;
+      try {
+        mcpConfig = JSON.parse(componentData.content);
+      } catch (error) {
+        throw new Error(`Failed to parse MCP content for ${componentData.name}: ${error.message}`);
+      }
+      
+      // Remove description field before merging (CLI processing)
+      if (mcpConfig.mcpServers) {
+        for (const serverName in mcpConfig.mcpServers) {
+          if (mcpConfig.mcpServers[serverName] && typeof mcpConfig.mcpServers[serverName] === 'object') {
+            delete mcpConfig.mcpServers[serverName].description;
+          }
+        }
+      }
+      
+      // Merge configurations
+      const mergedConfig = {
+        ...existingConfig,
+        ...mcpConfig
+      };
+      
+      // Deep merge mcpServers
+      if (existingConfig.mcpServers && mcpConfig.mcpServers) {
+        mergedConfig.mcpServers = {
+          ...existingConfig.mcpServers,
+          ...mcpConfig.mcpServers
+        };
+      }
+      
+      await fs.writeJson(targetMcpFile, mergedConfig, { spaces: 2 });
+      return;
+    }
+    
+    // Write content for agents and commands
+    if (targetPath) {
+      await fs.writeFile(targetPath, componentData.content, 'utf8');
+    }
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Error installing ${type} "${componentData.name}": ${error.message}`));
+    throw error;
+  }
 }
 
 /**
@@ -947,4 +1260,79 @@ ${workflowData.steps.map((step, index) => `# ${index + 1}. ${step.description} (
   return yaml;
 }
 
+/**
+ * Handle prompt execution in Claude Code
+ */
+async function handlePromptExecution(prompt, targetDir) {
+  console.log(chalk.blue('\n🎯 Prompt execution requested...'));
+  
+  // Ask user if they want to execute the prompt in Claude Code
+  const { shouldExecute } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'shouldExecute',
+    message: `Do you want to execute this prompt in Claude Code?\n${chalk.cyan(`"${prompt}"`)}`,
+    default: true
+  }]);
+  
+  if (!shouldExecute) {
+    console.log(chalk.yellow('⏹️  Prompt execution skipped by user.'));
+    return;
+  }
+  
+  console.log(chalk.blue('🚀 Preparing to launch Claude Code with your prompt...'));
+  
+  try {
+    // Check if claude command is available in PATH
+    const { spawn } = require('child_process');
+    const open = require('open');
+    
+    // First try to execute claude command directly
+    const claudeProcess = spawn('claude', [prompt], {
+      cwd: targetDir,
+      stdio: ['inherit', 'inherit', 'inherit'],
+      shell: true
+    });
+    
+    claudeProcess.on('error', async (error) => {
+      if (error.code === 'ENOENT') {
+        // Claude command not found, try alternative approaches
+        console.log(chalk.yellow('⚠️  Claude Code CLI not found in PATH.'));
+        console.log(chalk.blue('💡 Alternative ways to execute your prompt:'));
+        console.log(chalk.gray('   1. Install Claude Code CLI: https://claude.ai/code'));
+        console.log(chalk.gray('   2. Copy and paste this prompt in Claude Code interface:'));
+        console.log(chalk.cyan(`\n   "${prompt}"\n`));
+        
+        // Ask if user wants to open Claude Code web interface
+        const { openWeb } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'openWeb',
+          message: 'Would you like to open Claude Code in your browser?',
+          default: true
+        }]);
+        
+        if (openWeb) {
+          await open('https://claude.ai/code');
+          console.log(chalk.green('✅ Claude Code opened in your browser!'));
+          console.log(chalk.cyan(`Don't forget to paste your prompt: "${prompt}"`));
+        }
+      } else {
+        throw error;
+      }
+    });
+    
+    claudeProcess.on('close', (code) => {
+      if (code === 0) {
+        console.log(chalk.green('✅ Claude Code executed successfully!'));
+      } else if (code !== null) {
+        console.log(chalk.yellow(`⚠️  Claude Code exited with code ${code}`));
+      }
+    });
+    
+  } catch (error) {
+    console.log(chalk.red(`❌ Error executing prompt: ${error.message}`));
+    console.log(chalk.blue('💡 You can manually execute this prompt in Claude Code:'));
+    console.log(chalk.cyan(`"${prompt}"`));
+  }
+}
+
 module.exports = { createClaudeConfig, showMainMenu };