claude-code-templates 1.11.0 → 1.12.1

package/bin/create-claude-config.js

@@ -5,32 +5,39 @@ const chalk = require('chalk');
 const boxen = require('boxen');
 const { createClaudeConfig } = require('../src/index');
 
-// ASCII Art for Claude Code Templates
-const banner = chalk.hex('#D97706')(`
- ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
-██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
-██║     ██║     ███████║██║   ██║██║  ██║█████╗  
-██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  
-╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
- ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
-
- ██████╗ ██████╗ ██████╗ ███████╗
-██╔════╝██╔═══██╗██╔══██╗██╔════╝
-██║     ██║   ██║██║  ██║█████╗  
-██║     ██║   ██║██║  ██║██╔══╝  
-╚██████╗╚██████╔╝██████╔╝███████╗
- ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
-
-████████╗███████╗███╗   ███╗██████╗ ██╗      █████╗ ████████╗███████╗███████╗
-╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║     ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
-   ██║   █████╗  ██╔████╔██║██████╔╝██║     ███████║   ██║   █████╗  ███████╗
-   ██║   ██╔══╝  ██║╚██╔╝██║██╔═══╝ ██║     ██╔══██║   ██║   ██╔══╝  ╚════██║
-   ██║   ███████╗██║ ╚═╝ ██║██║     ███████╗██║  ██║   ██║   ███████╗███████║
-   ╚═╝   ╚══════╝╚═╝     ╚═╝╚═╝     ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
-`) +
-chalk.yellow('\n     🚀 Setup Claude Code for any project language 🚀');
-
-console.log(banner);
+const pkg = require('../package.json');
+
+const title = 'Claude Code Templates';
+const subtitle = 'Your starting point for Claude Code projects';
+
+const colorGradient = ['#EA580C', '#F97316', '#FB923C', '#FDBA74', '#FED7AA', '#FFEBD6'];
+
+function colorizeTitle(text) {
+  const chars = text.split('');
+  const steps = colorGradient.length;
+  return chars
+    .map((char, i) => {
+      const color = colorGradient[i % steps];
+      return chalk.hex(color)(char);
+    })
+    .join('');
+}
+
+console.clear();
+console.log(chalk.hex('#F97316')('════════════════════════════════════════════════════════════════'));
+console.log('\n');
+console.log('       🔮 ' + colorizeTitle(title));
+console.log('\n');
+console.log('       ' + chalk.hex('#FDBA74')(subtitle));
+console.log('\n');
+console.log(chalk.hex('#F97316')('════════════════════════════════════════════════════════════════\n'));
+
+console.log(
+  chalk.hex('#D97706')('🚀 Setup Claude Code for any project language 🚀') +
+  chalk.gray(`\n                             v${pkg.version}\n\n`) +
+  chalk.blue('🌐 Templates: ') + chalk.underline('https://davila7.github.io/claude-code-templates/') + '\n' +
+  chalk.blue('📖 Documentation: ') + chalk.underline('https://davila7.github.io/claude-code-templates/docu/')
+);
 
 program
   .name('create-claude-config')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "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": {
@@ -31,7 +31,6 @@
     "dev:link": "npm link",
     "dev:unlink": "npm unlink -g claude-code-templates",
     "pretest:commands": "npm run dev:link",
-    "prepublishOnly": "echo 'Skipping tests for emergency publish'",
     "analytics:start": "node src/analytics.js",
     "analytics:test": "npm run test:analytics"
   },

package/src/agents.js

@@ -0,0 +1,262 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+
+/**
+ * Get all available agents from the templates directory structure
+ * @returns {Array} Array of agent objects with name, description, and color
+ */
+function getAvailableAgents() {
+  const agents = [];
+  
+  try {
+    // Scan all language directories
+    const languageDirs = fs.readdirSync(TEMPLATES_DIR)
+      .filter(dir => {
+        const dirPath = path.join(TEMPLATES_DIR, dir);
+        return fs.statSync(dirPath).isDirectory() && dir !== 'common';
+      });
+    
+    for (const langDir of languageDirs) {
+      const frameworksPath = path.join(TEMPLATES_DIR, langDir, 'examples');
+      
+      if (fs.existsSync(frameworksPath)) {
+        const frameworks = fs.readdirSync(frameworksPath)
+          .filter(dir => {
+            const dirPath = path.join(frameworksPath, dir);
+            return fs.statSync(dirPath).isDirectory();
+          });
+        
+        for (const framework of frameworks) {
+          const agentsPath = path.join(frameworksPath, framework, 'agents');
+          
+          if (fs.existsSync(agentsPath)) {
+            const agentFiles = fs.readdirSync(agentsPath)
+              .filter(file => file.endsWith('.md'));
+            
+            for (const file of agentFiles) {
+              const filePath = path.join(agentsPath, file);
+              const content = fs.readFileSync(filePath, 'utf8');
+              const agent = parseAgentFile(content, file);
+              
+              if (agent) {
+                agent.language = langDir;
+                agent.framework = framework;
+                agent.filePath = filePath;
+                agents.push(agent);
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    return agents;
+  } catch (error) {
+    console.log(chalk.yellow('⚠️  No agents templates found'));
+    return [];
+  }
+}
+
+/**
+ * Parse agent markdown file to extract frontmatter
+ * @param {string} content - File content
+ * @param {string} filename - File name
+ * @returns {Object|null} Agent object or null if parsing fails
+ */
+function parseAgentFile(content, filename) {
+  try {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      return null;
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const lines = frontmatter.split('\n');
+    const agent = { filename };
+
+    for (const line of lines) {
+      const [key, ...valueParts] = line.split(':');
+      if (key && valueParts.length > 0) {
+        const value = valueParts.join(':').trim();
+        agent[key.trim()] = value;
+      }
+    }
+
+    // Extract description without examples for display
+    if (agent.description) {
+      const shortDesc = agent.description.split('Examples:')[0].trim();
+      agent.shortDescription = shortDesc;
+    }
+
+    return agent;
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️  Failed to parse agent file: ${filename}`));
+    return null;
+  }
+}
+
+/**
+ * Get agents that are relevant for a specific language/framework
+ * @param {string} language - Programming language
+ * @param {string} framework - Framework (optional)
+ * @returns {Array} Array of relevant agents
+ */
+function getAgentsForLanguageAndFramework(language, framework) {
+  const allAgents = getAvailableAgents();
+  
+  // Filter agents based on language and framework
+  return allAgents.filter(agent => {
+    // First check exact language match
+    if (agent.language !== language) {
+      return false;
+    }
+    
+    // If framework is specified and not 'none', check framework match
+    if (framework && framework !== 'none') {
+      // Extract framework name from framework path (e.g., 'react-app' -> 'react')
+      const frameworkName = framework.includes('-') ? framework.split('-')[0] : framework;
+      const agentFrameworkName = agent.framework.includes('-') ? agent.framework.split('-')[0] : agent.framework;
+      
+      return agentFrameworkName.toLowerCase().includes(frameworkName.toLowerCase());
+    }
+    
+    // If no specific framework, return all agents for this language
+    return true;
+  });
+}
+
+/**
+ * Install selected agents to the project's .claude/agents directory
+ * @param {Array} selectedAgents - Array of agent names to install
+ * @param {string} projectPath - Project directory path
+ * @returns {Promise<boolean>} Success status
+ */
+async function installAgents(selectedAgents, projectPath = process.cwd()) {
+  try {
+    const claudeDir = path.join(projectPath, '.claude');
+    const agentsDir = path.join(claudeDir, 'agents');
+    
+    // Create .claude/agents directory if it doesn't exist
+    await fs.ensureDir(agentsDir);
+    
+    let installedCount = 0;
+    const allAgents = getAvailableAgents();
+    
+    for (const agentName of selectedAgents) {
+      // Find the agent by name in the available agents
+      const agent = allAgents.find(a => a.name === agentName);
+      
+      if (agent && agent.filePath) {
+        const targetFile = path.join(agentsDir, `${agentName}.md`);
+        
+        if (await fs.pathExists(agent.filePath)) {
+          await fs.copy(agent.filePath, targetFile);
+          installedCount++;
+          console.log(chalk.green(`✓ Installed agent: ${agentName} (${agent.language}/${agent.framework})`));
+        } else {
+          console.log(chalk.yellow(`⚠️  Agent source file not found: ${agent.filePath}`));
+        }
+      } else {
+        console.log(chalk.yellow(`⚠️  Agent not found: ${agentName}`));
+      }
+    }
+    
+    if (installedCount > 0) {
+      console.log(chalk.green(`\n🎉 Successfully installed ${installedCount} agent(s) to .claude/agents/`));
+      console.log(chalk.blue('   You can now use these agents in your Claude Code conversations!'));
+      return true;
+    } else {
+      console.log(chalk.yellow('⚠️  No agents were installed'));
+      return false;
+    }
+    
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to install agents:'), error.message);
+    return false;
+  }
+}
+
+/**
+ * Check if project already has agents installed
+ * @param {string} projectPath - Project directory path
+ * @returns {Promise<Array>} Array of installed agent names
+ */
+async function getInstalledAgents(projectPath = process.cwd()) {
+  try {
+    const agentsDir = path.join(projectPath, '.claude', 'agents');
+    
+    if (!(await fs.pathExists(agentsDir))) {
+      return [];
+    }
+    
+    const agentFiles = await fs.readdir(agentsDir);
+    return agentFiles
+      .filter(file => file.endsWith('.md'))
+      .map(file => path.basename(file, '.md'));
+      
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Format agent choices for inquirer prompt
+ * @param {Array} agents - Array of agent objects
+ * @param {Array} installedAgents - Array of already installed agent names
+ * @returns {Array} Formatted choices for inquirer
+ */
+function formatAgentChoices(agents, installedAgents = []) {
+  return agents.map(agent => {
+    const isInstalled = installedAgents.includes(agent.name);
+    const colorFn = getColorFunction(agent.color);
+    
+    const name = isInstalled 
+      ? `${colorFn(agent.name)} ${chalk.dim('(already installed)')}`
+      : colorFn(agent.name);
+    
+    const description = agent.shortDescription || agent.description || 'No description available';
+    // Truncate description if too long
+    const truncatedDesc = description.length > 80 
+      ? description.substring(0, 80) + '...' 
+      : description;
+    
+    return {
+      name: `${name}\n  ${chalk.dim(truncatedDesc)}`,
+      value: agent.name,
+      short: agent.name,
+      disabled: isInstalled ? 'Already installed' : false
+    };
+  });
+}
+
+/**
+ * Get chalk color function based on color name
+ * @param {string} colorName - Color name
+ * @returns {Function} Chalk color function
+ */
+function getColorFunction(colorName) {
+  const colorMap = {
+    red: chalk.red,
+    green: chalk.green,
+    yellow: chalk.yellow,
+    blue: chalk.blue,
+    magenta: chalk.magenta,
+    cyan: chalk.cyan,
+    white: chalk.white,
+    gray: chalk.gray,
+    grey: chalk.gray
+  };
+  
+  return colorMap[colorName] || chalk.white;
+}
+
+module.exports = {
+  getAvailableAgents,
+  getAgentsForLanguageAndFramework,
+  installAgents,
+  getInstalledAgents,
+  formatAgentChoices
+};

package/src/analytics/core/ConversationAnalyzer.js

@@ -101,7 +101,7 @@ class ConversationAnalyzer {
 
         try {
           // Extract project name from path
-          const projectFromPath = this.extractProjectFromPath(filePath);
+          const projectFromPath = await this.extractProjectFromPath(filePath);
 
           // Use cached parsed conversation if available
           const parsedMessages = await this.getParsedConversation(filePath);
@@ -113,6 +113,9 @@ class ConversationAnalyzer {
           // Calculate tool usage data with caching
           const toolUsage = await this.getCachedToolUsage(filePath, parsedMessages);
 
+          const projectFromConversation = await this.extractProjectFromConversation(filePath);
+          const finalProject = projectFromConversation || projectFromPath;
+
           const conversation = {
             id: filename.replace('.jsonl', ''),
             filename: filename,
@@ -125,7 +128,7 @@ class ConversationAnalyzer {
             tokenUsage: tokenUsage,
             modelInfo: modelInfo,
             toolUsage: toolUsage,
-            project: projectFromPath || this.extractProjectFromConversation(parsedMessages),
+            project: finalProject,
             status: stateCalculator.determineConversationStatus(parsedMessages, stats.mtime),
             conversationState: stateCalculator.determineConversationState(parsedMessages, stats.mtime),
             statusSquares: await this.getCachedStatusSquares(filePath, parsedMessages),
@@ -433,11 +436,11 @@ class ConversationAnalyzer {
   }
 
   /**
-   * Extract project name from Claude directory file path
+   * Extract project name from Claude directory file path using settings.json
    * @param {string} filePath - Full path to conversation file
-   * @returns {string|null} Project name or null
+   * @returns {Promise<string|null>} Project name or null
    */
-  extractProjectFromPath(filePath) {
+  async extractProjectFromPath(filePath) {
     // Extract project name from file path like:
     // /Users/user/.claude/projects/-Users-user-Projects-MyProject/conversation.jsonl
     const pathParts = filePath.split('/');
@@ -445,34 +448,73 @@ class ConversationAnalyzer {
 
     if (projectIndex !== -1 && projectIndex + 1 < pathParts.length) {
       const projectDir = pathParts[projectIndex + 1];
-      // Clean up the project directory name
-      const cleanName = projectDir
-        .replace(/^-/, '')
-        .replace(/-/g, '/')
-        .split('/')
-        .pop() || 'Unknown';
-
-      return cleanName;
+      
+      // Try to read the settings.json file for this project
+      try {
+        const projectPath = path.join(path.dirname(filePath)); // Directory containing the conversation file
+        const settingsPath = path.join(projectPath, 'settings.json');
+        
+        if (await fs.pathExists(settingsPath)) {
+          const settingsContent = await fs.readFile(settingsPath, 'utf8');
+          const settings = JSON.parse(settingsContent);
+          
+          if (settings.projectName) {
+            return settings.projectName;
+          }
+          
+          // If no projectName in settings, try to extract from projectPath
+          if (settings.projectPath) {
+            return path.basename(settings.projectPath);
+          }
+        }
+      } catch (error) {
+        // If we can't read settings.json, fall back to parsing the directory name
+        console.warn(chalk.yellow(`Warning: Could not read settings.json for project ${projectDir}:`, error.message));
+      }
+      
+      // Fallback: we'll extract project name from conversation content instead
+      // For now, return null to trigger reading from conversation file
+      return null;
     }
 
     return null;
   }
 
+
   /**
    * Attempt to extract project information from conversation content
-   * @param {Array} messages - Array of message objects
-   * @returns {string} Project name or 'Unknown'
-   */
-  extractProjectFromConversation(messages) {
-    // Try to extract project information from conversation
-    for (const message of messages.slice(0, 5)) {
-      if (message.content && typeof message.content === 'string') {
-        const pathMatch = message.content.match(/\/([^\/\s]+)$/);
-        if (pathMatch) {
-          return pathMatch[1];
+   * @param {string} filePath - Path to the conversation file
+   * @returns {Promise<string>} Project name or 'Unknown'
+   */
+  async extractProjectFromConversation(filePath) {
+    try {
+      // Read the conversation file and look for cwd field
+      const content = await this.getFileContent(filePath);
+      const lines = content.trim().split('\n').filter(line => line.trim());
+      
+      for (const line of lines.slice(0, 10)) { // Check first 10 lines
+        try {
+          const item = JSON.parse(line);
+          
+          // Look for cwd field in the message
+          if (item.cwd) {
+            const projectName = path.basename(item.cwd);
+            return projectName;
+          }
+          
+          // Also check if it's in nested objects
+          if (item.message && item.message.cwd) {
+            return path.basename(item.message.cwd);
+          }
+        } catch (parseError) {
+          // Skip invalid JSON lines
+          continue;
         }
       }
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Could not extract project from conversation ${filePath}:`, error.message));
     }
+    
     return 'Unknown';
   }