ccstart 2.0.0 → 2.0.1

package/README.md

@@ -21,325 +21,106 @@ npm install -g ccstart
 ccstart my-project
 ```
 
-## Command Line Options
-
-```bash
-ccstart [project-name] [options]
-
-Options:
-  --force, -f     Skip all prompts and overwrite existing files
-  --dry-run, -d   Show what would be done without making changes
-  --agents        Interactive agent selection mode
-  --all-agents    Include all agents without prompting
-  --no-agents     Skip agent selection entirely
-  --help, -h      Show help message
-
-Examples:
-  ccstart                    # Create in current directory
-  ccstart my-project         # Create in new directory
-  ccstart . --force          # Overwrite files in current directory
-  ccstart my-app --dry-run   # Preview changes without creating files
-  ccstart --agents           # Interactive agent selection only
-  ccstart my-app --all-agents # Include all agents automatically
-```
-
 ## What's Included
 
-The boilerplate template creates:
 - **CLAUDE.md** - Project instructions for Claude (references claude/ subdirectories)
 - **claude/** - All Claude-related files in one organized directory:
-  - **claude/agents/** - Specialized AI agents (planner, coder, checker, etc.)
-  - **claude/tickets/** - Task tracking system
-  - **claude/plans/** - Project planning documents
-  - **claude/docs/** - Documentation with ROADMAP.md and agent-orchestration.md
-- **.claude/** - Claude Code specific directory structure (created automatically)
+  - **agents/** - 8 specialized AI agents (planner, coder, checker, researcher, etc.)
+  - **tickets/** - Task tracking system with ticket templates
+  - **plans/** - Project planning documents
+  - **docs/** - ROADMAP.md and agent orchestration workflows
+- **.claude/** - Claude Code configuration (created automatically):
+  - **agents/** - Selected agents for Claude Code integration
+  - **commands/** - Custom slash commands including `/update-claude-md`
+  - **hooks/** - Automatic workflow detection
+  - **settings.json.example** - Hook configuration
 
 ## Key Features
 
 - 🎯 **Interactive Agent Selection** - Choose which agents to include during setup
-- 🔄 **Agent Orchestration Workflows** - Pre-defined workflows that automatically coordinate multiple agents for complex tasks
+- 🔄 **Agent Orchestration Workflows** - Pre-defined workflows that coordinate multiple agents
 - 🔒 **Smart Conflict Resolution** - Handle existing files with skip/rename/overwrite options
-- 📁 **.claude Directory Support** - Automatic creation of Claude Code directory structure
+- 📁 **Auto-detects Claude Code** - Creates .claude directory structure automatically
 - 🏃 **Dry Run Mode** - Preview changes before applying them
 - ⚡ **Force Mode** - Skip all prompts for automated workflows
-- 🎨 **Standalone Agent Preview** - Explore available agents without setup
-- 🎭 **Systematic Task Execution** - Agents work in sequence, building on each other's outputs
-
-## Project Structure
-
-- **templates/** - The boilerplate templates that will be copied to user's project
-- **bin/** - CLI executable for ccstart
-- **agents/**, **docs/**, **plans/**, **tickets/** - Working files for ccstart development (not part of the template)
-
-## Usage
-
-1. Create a new project:
-   ```bash
-   npx ccstart my-awesome-project
-   cd my-awesome-project
-   ```
-
-2. Edit `CLAUDE.md` with your project-specific instructions
-
-3. Update `claude/docs/ROADMAP.md` with your project goals
-
-4. Start creating tickets in `claude/tickets/` directory
-
-## Claude Code Integration
-
-ccstart seamlessly integrates with Claude Code:
-
-- **Automatic Detection** - Checks if Claude Code is initialized in your project
-- **.claude Directory** - Creates Claude Code directory structure automatically
-- **Agent Installation** - Copies agents to `.claude/agents/` for native Claude Code support
-- **Smart Initialization** - Offers to create `.claude` directory if Claude Code isn't detected
-
-When running in the current directory (`npx ccstart .`), it will check for Claude Code and provide instructions if not found. For new projects, ccstart will remind you to initialize Claude Code after setup.
-
-## Using Agents
-
-The boilerplate includes several specialized agents in the `agents/` directory:
-
-- **planner.md** - Strategic planning and task breakdown
-- **coder.md** - Implementation and development
-- **checker.md** - Testing and quality assurance
-- **researcher.md** - Research and information gathering
-- **blockchain.md** - Web3 and smart contract development
-- **frontend.md** - UI/UX and frontend development
-- **backend.md** - API design and server-side development
-- **shadcn.md** - shadcn/ui component development
-
-### Interactive Agent Selection
-
-During setup, ccstart will prompt you to select which agents to include:
-
-```bash
-🤖 Select agents to include in your Claude Code project
-
-Use arrow keys to navigate, space to select/deselect, 'a' to toggle all
-
-Choose your agents:
-◯ backend - Backend development specialist for API design and server optimization
-◯ blockchain - Web3 and smart contract development expert
-◯ checker - Quality assurance and code review specialist
-◯ coder - Expert software developer for implementation
-◯ frontend - Frontend development specialist for UI/UX
-◯ planner - Strategic planning specialist for complex problems
-◯ researcher - Research specialist for documentation and code analysis
-◯ shadcn - shadcn/ui component library expert
-```
+- 🎭 **Workflow Commands** - Execute complex workflows with single commands
+- 🪝 **Intelligent Hooks** - Automatically detect task patterns and suggest workflows
 
-You can also use flags to control agent selection:
-- `--all-agents` - Include all available agents
-- `--no-agents` - Skip agent selection entirely
-- `--agents` - Preview available agents without creating a project
+## Quick Start
 
-Example:
 ```bash
-# Include all agents without prompting
-npx ccstart my-project --all-agents
-
-# Create project without any agents
-npx ccstart my-project --no-agents
+npx ccstart my-project
+cd my-project
 
-# Preview available agents only
-npx ccstart --agents
+# Edit CLAUDE.md with your project details
+# Start using Claude Code with pre-configured agents and workflows
 ```
 
-### Conflict Resolution
-
-When existing files are detected, ccstart offers smart conflict resolution:
+## Command Line Options
 
 ```bash
-⚠️  File conflicts detected. You will be asked how to handle each category.
-
-📄 CLAUDE.md conflicts:
-  - CLAUDE.md
-
-Conflict resolution options:
-  1) skip      (s) - Keep your existing files
-  2) rename    (r) - Save template files with -ccstart suffix
-  3) overwrite (o) - Replace with template versions
-
-Your choice for CLAUDE.md [s/r/o]: 
-```
-
-Categories are handled separately:
-- **CLAUDE.md** - Project instructions (warns before overwriting)
-- **Agents** - AI agent files
-- **Documentation** - docs/ folder files
-- **Plans** - plans/ folder files
-- **Tickets** - tickets/ folder files
-
-## Agent Orchestration Showcase
-
-The template includes powerful agent orchestration workflows that guide Claude through complex tasks systematically. Here are real-world examples:
-
-### 🚀 Feature Development Example
+ccstart [project-name] [options]
 
-**Scenario**: Building a user authentication system
+Options:
+  --force, -f     Skip all prompts and overwrite existing files
+  --dry-run, -d   Show what would be done without making changes
+  --agents        Interactive agent selection mode
+  --all-agents    Include all agents without prompting
+  --no-agents     Skip agent selection entirely
+  --help, -h      Show help message
 
-```bash
-# In Claude Code, you would say:
-"I need to add user authentication to my app. Use the feature development workflow to guide me through this."
-
-# Claude will automatically orchestrate:
-1. Researcher Agent → Analyzes existing codebase, identifies auth patterns
-2. Planner Agent → Creates detailed implementation plan with JWT, sessions, etc.
-3. Coder Agent → Implements auth endpoints, middleware, and UI components
-4. Checker Agent → Tests security, validates implementation, checks edge cases
+Examples:
+  ccstart my-app --all-agents  # Include all agents
+  ccstart . --force            # Overwrite in current directory
+  ccstart --agents             # Preview available agents
 ```
 
-### 🐛 Bug Fix Example
+## Agent Orchestration
 
-**Scenario**: Users report login failures after 5 minutes
+The template includes pre-configured workflows that automatically coordinate agents:
 
-```bash
-# You tell Claude:
-"Users are getting logged out after 5 minutes. Use the bug fix workflow to investigate and fix this."
+- **Feature Development** → Researcher → Planner → Coder → Checker
+- **Bug Fix** → Researcher → Coder → Checker
+- **API Development** → Planner → Backend → Frontend → Checker
+- **Refactoring** → Researcher → Planner → Coder → Checker
+- **UI Components** → Frontend → Shadcn → Checker
+- **Quality Assurance** → Researcher → Checker → Coder → Checker
 
-# Claude orchestrates:
-1. Researcher Agent → Investigates session handling, token expiry, logs
-2. Coder Agent → Fixes token refresh logic, updates session timeout
-3. Checker Agent → Verifies fix, tests edge cases, ensures no regressions
-```
+See `claude/docs/agent-orchestration.md` for detailed workflow documentation.
 
-### 🏗️ API Development Example
+## Custom Commands & Hooks
 
-**Scenario**: Building a REST API for a blog platform
+### Slash Commands
+- `/update-claude-md` - Automatically populate project information in CLAUDE.md
+- `/workflow-*` commands - Execute orchestrated workflows (coming soon)
 
-```bash
-# You request:
-"Help me build a complete REST API for blog posts with CRUD operations. Follow the API development workflow."
-
-# Claude coordinates:
-1. Planner Agent → Designs RESTful endpoints, database schema, auth strategy
-2. Backend Agent → Implements controllers, models, middleware, validation
-3. Frontend Agent → Creates API client, integration examples (if needed)
-4. Checker Agent → Tests all endpoints, validates OpenAPI spec, security audit
-```
+### Automatic Workflow Detection
+Hooks automatically detect task patterns and suggest appropriate workflows:
+- Feature requests → suggests `/workflow-feature`
+- Bug reports → suggests `/workflow-bug`
+- API tasks → suggests `/workflow-api`
+- And more! (QA, refactoring, UI components, blockchain)
 
-### 🎨 UI Component Example
+Hooks are automatically enabled - no setup required!
 
-**Scenario**: Creating a responsive dashboard with shadcn/ui
+## Local Development
 
 ```bash
-# You ask:
-"Create a dashboard with charts and stats cards using shadcn. Use the UI component workflow."
-
-# Claude executes:
-1. Frontend Agent → Designs component structure, responsive layout
-2. Shadcn Agent → Implements with shadcn/ui components, themes, animations
-3. Checker Agent → Tests responsiveness, accessibility, performance
-```
-
-### 🔍 Quality Assurance Example
+# Method 1: npm link (Recommended)
+cd /path/to/ccstart
+npm link
+ccstart test-project
 
-**Scenario**: Comprehensive review before deployment
+# Method 2: Direct execution
+node bin/create-project.js ../test-project
 
-```bash
-# You request:
-"Run full QA on the authentication feature we just built."
-
-# Claude performs:
-1. Researcher Agent → Analyzes all changes, identifies test requirements
-2. Checker Agent → Runs security scans, performance tests, accessibility checks
-3. Coder Agent → Fixes any issues found
-4. Checker Agent → Final validation, generates QA report
+# Clean up
+npm unlink -g ccstart
 ```
 
-### 💡 How to Use Agent Orchestration
-
-1. **Read the orchestration guide**:
-   ```
-   "Read docs/agent-orchestration.md to understand available workflows"
-   ```
-
-2. **Choose your workflow**:
-   - Feature Development: Complex new features
-   - Bug Fix: Investigating and fixing issues
-   - Refactoring: Improving code quality
-   - API Development: Building APIs
-   - UI Components: Frontend development
-   - Blockchain: Web3 features
-   - QA: Quality assurance
-
-3. **Let Claude guide you**:
-   ```
-   "I need to [your task]. Which workflow should we use?"
-   ```
-
-4. **Follow the flow**:
-   - Claude will automatically use agents in the correct sequence
-   - Each agent builds on the previous one's work
-   - You get systematic, thorough results
-
-The orchestration ensures nothing is missed and follows best practices automatically!
-
-## Getting Started with Claude Code
-
-After setting up your project with `ccstart`:
-
-1. **Open Claude Code** in your project directory:
-   ```bash
-   cd my-awesome-project
-   claude
-   ```
-
-2. **Let Claude understand your project** by asking:
-   - "Read the CLAUDE.md file to understand this project"
-   - "Check the roadmap in docs/ROADMAP.md"
-   - "What agents are available in the agents directory?"
-   - "Read the README files in docs, tickets, and plans folders to understand the workflow"
-
-3. **Start working** with Claude:
-   - Use the planner agent: "Use the planner agent to help me design a user authentication system"
-   - Create tickets: "Create a ticket for implementing user login"
-   - Implement features: "Use the coder agent to implement the login functionality"
-   - Review code: "Use the checker agent to review the code we just wrote"
-
-4. **Important setup steps**:
-   - **Update ROADMAP.md**: Define your project's goals, features, and development phases
-   - **Read folder documentation**: Each folder (docs/, tickets/, plans/) has a README explaining its purpose and format
-   - **Customize CLAUDE.md**: Add project-specific instructions, commands, and context
-
-5. **Workflow tips**:
-   - Always start with planning for complex features
-   - Create tickets to track progress
-   - Use the appropriate agent for each task
-   - Keep CLAUDE.md updated with project-specific instructions
-   - Follow the workflow defined in docs/ROADMAP.md
-
-## Features
-
-### Core Features
-- ✅ Pre-configured project structure for Claude Code
-- 🤖 Multiple specialized agents for different tasks
-- 🎫 Built-in ticket and planning system
-- 📋 Ready-to-use boilerplate with best practices
-- 📁 Automatic .claude directory integration
-
-### CLI Features
-- 🎯 Interactive agent selection with descriptions
-- 🔄 Smart conflict resolution (skip/rename/overwrite)
-- 👀 Dry-run mode to preview changes
-- ⚡ Force mode for CI/CD pipelines
-- 🎨 Standalone agent preview mode
-- 🛡️ Security validations for file operations
-
-### Agent Orchestration
-The template includes `docs/agent-orchestration.md` which defines workflows for:
-- **Feature Development** - Researcher → Planner → Coder → Checker
-- **Bug Fixes** - Researcher → Coder → Checker
-- **Refactoring** - Researcher → Planner → Coder → Checker
-- **API Development** - Planner → Backend → Frontend → Checker
-- **UI Components** - Frontend → Shadcn → Checker
-- **Blockchain** - Planner → Blockchain → Checker
-- **Quality Assurance** - Researcher → Checker → Coder → Checker
-
 ## Credits
 
-Born from our discussions in TechOverflow with [vichannnnn](https://github.com/vichannnnn) and [nasdin](https://github.com/nasdin)
+Born from our discussions in TechOverflow with [vichannnnn](https://github.com/vichannnnn), [MrMarciaOng](https://github.com/MrMarciaOng), and [nasdin](https://github.com/nasdin)
 
 ## License
 

package/bin/create-project.bak.js

@@ -1004,7 +1004,7 @@ async function main() {
     console.log(`  ⏭️  Skipped ${claudeInitResult.skippedAgents} existing agents in .claude/agents`);
   }
 
-  console.log(`\n✅ Claude Code project ${flags.dryRun ? 'would be' : ''} created successfully!`);
+  console.log(`\n✅ Claude Code project ${flags.dryRun ? 'would be' : ''}created successfully!`);
   
   // Show summary of what happened
   if (fileConflicts.length > 0 || copiedCount > 0 || selectedAgentFiles.length > 0 || claudeInitResult) {

package/bin/create-project.js

@@ -369,6 +369,176 @@ async function initializeClaudeDirectory(selectedAgentFiles, conflictStrategy, d
       }
     }
     
+    // Copy .claude/commands directory
+    const claudeCommandsDir = path.join(claudeDir, 'commands');
+    const templateCommandsDir = path.join(templateDir, '.claude', 'commands');
+    
+    if (fs.existsSync(templateCommandsDir)) {
+      // Create .claude/commands directory
+      if (!fs.existsSync(claudeCommandsDir)) {
+        if (!dryRun) {
+          fs.mkdirSync(claudeCommandsDir, { recursive: true });
+        }
+        createdItems.push('.claude/commands/');
+        if (dryRun) {
+          console.log('  📁 Would create directory: .claude/commands/');
+        }
+      }
+      
+      // Copy all files from template commands directory
+      const commandFiles = fs.readdirSync(templateCommandsDir);
+      for (const commandFile of commandFiles) {
+        const commandSrc = path.join(templateCommandsDir, commandFile);
+        const commandDest = path.join(claudeCommandsDir, commandFile);
+        
+        if (fs.statSync(commandSrc).isFile()) {
+          if (!fs.existsSync(commandDest)) {
+            if (!dryRun) {
+              fs.copyFileSync(commandSrc, commandDest);
+            }
+            createdItems.push(`.claude/commands/${commandFile}`);
+            if (dryRun) {
+              console.log(`  ✨ Would copy: .claude/commands/${commandFile}`);
+            }
+          } else {
+            if (conflictStrategy === 'overwrite') {
+              if (!dryRun) {
+                fs.copyFileSync(commandSrc, commandDest);
+              }
+              if (dryRun) {
+                console.log(`  ♻️  Would replace: .claude/commands/${commandFile}`);
+              }
+            } else if (conflictStrategy === 'rename') {
+              const ext = path.extname(commandFile);
+              const baseName = path.basename(commandFile, ext);
+              let newDest = path.join(claudeCommandsDir, `${baseName}-ccstart${ext}`);
+              let counter = 1;
+              while (fs.existsSync(newDest)) {
+                newDest = path.join(claudeCommandsDir, `${baseName}-ccstart-${counter}${ext}`);
+                counter++;
+              }
+              if (!dryRun) {
+                fs.copyFileSync(commandSrc, newDest);
+              }
+              const relativePath = path.relative(claudeDir, newDest);
+              createdItems.push(relativePath);
+              if (dryRun) {
+                console.log(`  📄 Would create: ${relativePath}`);
+              }
+            } else {
+              skippedItems.push(`.claude/commands/${commandFile}`);
+              if (dryRun) {
+                console.log(`  ⏭️  Would skip: .claude/commands/${commandFile}`);
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    // Copy .claude/hooks directory
+    const claudeHooksDir = path.join(claudeDir, 'hooks');
+    const templateHooksDir = path.join(templateDir, '.claude', 'hooks');
+    
+    if (fs.existsSync(templateHooksDir)) {
+      // Create .claude/hooks directory
+      if (!fs.existsSync(claudeHooksDir)) {
+        if (!dryRun) {
+          fs.mkdirSync(claudeHooksDir, { recursive: true });
+        }
+        createdItems.push('.claude/hooks/');
+        if (dryRun) {
+          console.log('  📁 Would create directory: .claude/hooks/');
+        }
+      }
+      
+      // Copy all files from template hooks directory
+      const hookFiles = fs.readdirSync(templateHooksDir);
+      for (const hookFile of hookFiles) {
+        const hookSrc = path.join(templateHooksDir, hookFile);
+        const hookDest = path.join(claudeHooksDir, hookFile);
+        
+        if (fs.statSync(hookSrc).isFile()) {
+          if (!fs.existsSync(hookDest)) {
+            if (!dryRun) {
+              fs.copyFileSync(hookSrc, hookDest);
+              // Make shell scripts executable
+              if (hookFile.endsWith('.sh')) {
+                fs.chmodSync(hookDest, '755');
+              }
+            }
+            createdItems.push(`.claude/hooks/${hookFile}`);
+            if (dryRun) {
+              console.log(`  ✨ Would copy: .claude/hooks/${hookFile}`);
+            }
+          } else {
+            if (conflictStrategy === 'overwrite') {
+              if (!dryRun) {
+                fs.copyFileSync(hookSrc, hookDest);
+                if (hookFile.endsWith('.sh')) {
+                  fs.chmodSync(hookDest, '755');
+                }
+              }
+              if (dryRun) {
+                console.log(`  ♻️  Would replace: .claude/hooks/${hookFile}`);
+              }
+            } else if (conflictStrategy === 'rename') {
+              const ext = path.extname(hookFile);
+              const baseName = path.basename(hookFile, ext);
+              let newDest = path.join(claudeHooksDir, `${baseName}-ccstart${ext}`);
+              let counter = 1;
+              while (fs.existsSync(newDest)) {
+                newDest = path.join(claudeHooksDir, `${baseName}-ccstart-${counter}${ext}`);
+                counter++;
+              }
+              if (!dryRun) {
+                fs.copyFileSync(hookSrc, newDest);
+                if (newDest.endsWith('.sh')) {
+                  fs.chmodSync(newDest, '755');
+                }
+              }
+              const relativePath = path.relative(claudeDir, newDest);
+              createdItems.push(relativePath);
+              if (dryRun) {
+                console.log(`  📄 Would create: ${relativePath}`);
+              }
+            } else {
+              skippedItems.push(`.claude/hooks/${hookFile}`);
+              if (dryRun) {
+                console.log(`  ⏭️  Would skip: .claude/hooks/${hookFile}`);
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    // Copy settings.json.example if it doesn't exist
+    const settingsExampleSrc = path.join(templateDir, '.claude', 'settings.json.example');
+    const settingsExampleDest = path.join(claudeDir, 'settings.json.example');
+    
+    if (fs.existsSync(settingsExampleSrc) && !fs.existsSync(settingsExampleDest)) {
+      if (!dryRun) {
+        fs.copyFileSync(settingsExampleSrc, settingsExampleDest);
+      }
+      createdItems.push('.claude/settings.json.example');
+      if (dryRun) {
+        console.log('  ✨ Would copy: .claude/settings.json.example');
+      }
+    }
+    
+    // Also create settings.json from the example if it doesn't exist
+    const settingsJsonDest = path.join(claudeDir, 'settings.json');
+    if (fs.existsSync(settingsExampleSrc) && !fs.existsSync(settingsJsonDest)) {
+      if (!dryRun) {
+        fs.copyFileSync(settingsExampleSrc, settingsJsonDest);
+      }
+      createdItems.push('.claude/settings.json');
+      if (dryRun) {
+        console.log('  ✨ Would create: .claude/settings.json (with hooks enabled)');
+      }
+    }
+    
     return {
       createdItems,
       skippedItems,
@@ -1049,17 +1219,17 @@ async function main() {
     console.log(`  ⏭️  Skipped ${claudeInitResult.skippedAgents} existing agents in .claude/agents`);
   }
 
-  console.log(`\n✅ Claude Code project ${flags.dryRun ? 'would be' : ''} created successfully!`);
+  console.log(`\n✅ Claude Code project ${flags.dryRun ? 'would be ' : ''}created successfully!`);
   
   // Show summary of what happened
   if (fileConflicts.length > 0 || copiedCount > 0 || selectedAgentFiles.length > 0 || claudeInitResult) {
     console.log('\n📊 Summary:');
-    if (copiedCount > 0) console.log(`  ✨ ${copiedCount} new files ${flags.dryRun ? 'would be' : ''} copied`);
-    if (skippedCount > 0) console.log(`  ⏭️  ${skippedCount} existing files ${flags.dryRun ? 'would be' : ''} kept unchanged`);
-    if (renamedCount > 0) console.log(`  📄 ${renamedCount} template files ${flags.dryRun ? 'would be' : ''} saved with -ccstart suffix`);
-    if (overwrittenCount > 0) console.log(`  ♻️  ${overwrittenCount} files ${flags.dryRun ? 'would be' : ''} replaced with template versions`);
+    if (copiedCount > 0) console.log(`  ✨ ${copiedCount} new files ${flags.dryRun ? 'would be ' : ''}copied`);
+    if (skippedCount > 0) console.log(`  ⏭️  ${skippedCount} existing files ${flags.dryRun ? 'would be ' : ''}kept unchanged`);
+    if (renamedCount > 0) console.log(`  📄 ${renamedCount} template files ${flags.dryRun ? 'would be ' : ''}saved with -ccstart suffix`);
+    if (overwrittenCount > 0) console.log(`  ♻️  ${overwrittenCount} files ${flags.dryRun ? 'would be ' : ''}replaced with template versions`);
     if (!flags.noAgents && !flags.dryRun) {
-      console.log(`  🤖 ${selectedAgentFiles.length} agent${selectedAgentFiles.length === 1 ? '' : 's'} ${flags.dryRun ? 'would be' : ''} included in claude/agents`);
+      console.log(`  🤖 ${selectedAgentFiles.length} agent${selectedAgentFiles.length === 1 ? '' : 's'} ${flags.dryRun ? 'would be ' : ''}included in claude/agents`);
     }
     if (claudeInitResult && claudeInitResult.createdItems.length > 0) {
       console.log(`  📁 ${claudeInitResult.createdItems.length} items created in .claude directory`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstart",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Start your Claude Code projects with a well-organized structure including agents, tickets, plans and orchestration workflows",
   "bin": {
     "ccstart": "bin/create-project.js"
@@ -22,9 +22,9 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vichannnnn/claude-code.git"
+    "url": "git+https://github.com/vichannnnn/ccstart.git"
   },
-  "homepage": "https://github.com/vichannnnn/claude-code#readme",
+  "homepage": "https://github.com/vichannnnn/ccstart#readme",
   "files": [
     "bin/",
     "template/",

package/template/.claude/commands/README.md

@@ -0,0 +1,70 @@
+# Claude Code Custom Commands
+
+This directory contains custom slash commands for Claude Code. These commands enhance your development workflow by providing project-specific functionality.
+
+## Available Commands
+
+### /update-claude-md
+Updates the CLAUDE.md file with project-specific information automatically detected from your codebase.
+
+Usage: `/update-claude-md`
+
+## Creating Custom Commands
+
+To create a new custom command:
+
+1. Create a new `.md` file in this directory (e.g., `my-command.md`)
+2. The filename becomes the command name (e.g., `/my-command`)
+3. Add your command prompt or instructions in the file
+
+### Command Structure
+
+Basic command:
+```markdown
+Analyze the codebase and provide a summary of the architecture
+```
+
+Command with frontmatter:
+```markdown
+---
+description: "Analyze project architecture"
+allowedTools: ["Read", "Grep", "LS"]
+model: "claude-3-sonnet-20240229"
+---
+
+Analyze the codebase structure and provide:
+1. Project architecture overview
+2. Key components and their relationships
+3. Technology stack summary
+```
+
+### Using Arguments
+
+Commands can accept arguments using `$ARGUMENTS`:
+```markdown
+Search for all occurrences of "$ARGUMENTS" in the codebase and list the files
+```
+
+Usage: `/search-term useState`
+
+### Executing Bash Commands
+
+You can include bash commands to be executed:
+```markdown
+Run the following command and analyze the output:
+```bash
+npm test
+```
+```
+
+## Command Naming
+
+- Use lowercase letters and hyphens
+- Be descriptive but concise
+- Examples: `update-docs`, `run-tests`, `analyze-deps`
+
+## Subdirectories
+
+You can organize commands in subdirectories for namespacing:
+- `.claude/commands/git/status.md` → `/git/status`
+- `.claude/commands/npm/audit.md` → `/npm/audit`

package/template/.claude/commands/update-claude-md.md

@@ -0,0 +1,23 @@
+---
+description: "Automatically update CLAUDE.md with project-specific information"
+allowedTools: ["Read", "Write", "Edit", "Grep", "LS", "Bash"]
+---
+
+I'll analyze your project and automatically update the CLAUDE.md file with project-specific information.
+
+First, let me examine your project structure to understand:
+1. Project type and technology stack
+2. Available scripts and commands
+3. Directory structure
+4. Dependencies and frameworks
+5. Testing and build configurations
+
+Then I'll update the following sections in CLAUDE.md:
+- Project Overview
+- Key Objectives (based on README if available)
+- Common Commands
+- Additional Notes
+
+I'll preserve any existing custom content you've added while updating the auto-generated sections.
+
+Let me start by analyzing your project...

package/template/.claude/hooks/README.md

@@ -0,0 +1,65 @@
+# Claude Code Hooks
+
+This directory contains hooks that automatically enhance Claude's behavior based on your interactions.
+
+## Available Hooks
+
+### workflow-detector.sh
+Automatically detects when you're describing a task that matches one of our workflow patterns and suggests the appropriate workflow command.
+
+**Detects:**
+- Feature development requests
+- Bug reports and fixes
+- API development tasks
+- QA and testing requests
+- Refactoring needs
+- UI component development
+
+### How It Works
+When you type a message to Claude, the hook analyzes it for patterns and adds helpful context suggesting the appropriate workflow command.
+
+## Setup
+
+1. **Enable hooks in Claude Code settings**:
+   Create or update `.claude/settings.json`:
+   ```json
+   {
+     "hooks": {
+       "UserPromptSubmit": [
+         {
+           "hooks": [
+             {
+               "type": "command",
+               "command": ".claude/hooks/workflow-detector.sh"
+             }
+           ]
+         }
+       ]
+     }
+   }
+   ```
+
+2. **Make hooks executable**:
+   ```bash
+   chmod +x .claude/hooks/*.sh
+   ```
+
+## Examples
+
+### Input: "I need to add user authentication to my app"
+**Hook adds**: "Detected feature request. Consider using /workflow-feature command for systematic implementation."
+
+### Input: "Fix the bug where users get logged out after 5 minutes"
+**Hook adds**: "Detected bug report. Consider using /workflow-bug command for systematic debugging."
+
+### Input: "Create REST API for managing blog posts"
+**Hook adds**: "Detected API development task. Consider using /workflow-api command."
+
+## Creating Custom Hooks
+
+You can create your own hooks by:
+1. Adding a new script to this directory
+2. Updating `.claude/settings.json` to reference it
+3. Using exit codes and JSON output to control behavior
+
+See Claude Code documentation for more details on hook development.

package/template/.claude/hooks/workflow-detector.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# workflow-detector.sh - Detects workflow patterns in user prompts
+# and suggests appropriate workflow commands
+
+input=$(cat)
+
+# Store original input for passthrough
+original_input="$input"
+
+# Initialize suggestions array
+suggestions=""
+
+# Detect feature requests
+if echo "$input" | grep -iE "(implement|add|create|build|develop).*(feature|functionality|component|system)" > /dev/null; then
+  suggestions="${suggestions}🚀 Detected feature development task. Consider using: /workflow-feature [your feature description]\n"
+fi
+
+# Detect bug reports
+if echo "$input" | grep -iE "(fix|bug|error|issue|broken|not working|problem|crash)" > /dev/null; then
+  suggestions="${suggestions}🐛 Detected bug fix task. Consider using: /workflow-bug [issue description]\n"
+fi
+
+# Detect API development
+if echo "$input" | grep -iE "(api|endpoint|rest|graphql|route).*(create|implement|build|design)" > /dev/null; then
+  suggestions="${suggestions}🔌 Detected API development task. Consider using: /workflow-api [API description]\n"
+fi
+
+# Detect QA/testing requests
+if echo "$input" | grep -iE "(test|qa|quality|review|audit|check).*(feature|code|implementation|system)" > /dev/null; then
+  suggestions="${suggestions}🧪 Detected QA task. Consider using: /workflow-qa [what to test]\n"
+fi
+
+# Detect refactoring needs
+if echo "$input" | grep -iE "(refactor|improve|optimize|clean up|restructure).*(code|implementation|architecture)" > /dev/null; then
+  suggestions="${suggestions}🔧 Detected refactoring task. Consider using: /workflow-refactor [what to refactor]\n"
+fi
+
+# Detect UI component development
+if echo "$input" | grep -iE "(ui|interface|component|frontend|design).*(create|implement|build|develop)" > /dev/null; then
+  suggestions="${suggestions}🎨 Detected UI development task. Consider using: /workflow-ui [component description]\n"
+fi
+
+# Detect blockchain/web3 development
+if echo "$input" | grep -iE "(blockchain|smart contract|web3|defi|nft|crypto)" > /dev/null; then
+  suggestions="${suggestions}⛓️ Detected blockchain task. Consider using: /workflow-blockchain [blockchain feature]\n"
+fi
+
+# If we detected any patterns, add suggestions as additional context
+if [ -n "$suggestions" ]; then
+  # Create JSON response with additional context
+  context="💡 Workflow Suggestions:\\n${suggestions}\\nThese commands will automatically orchestrate the appropriate agents for your task."
+  
+  # Escape for JSON
+  context=$(echo -n "$context" | sed 's/"/\\"/g')
+  
+  # Output JSON with additional context
+  echo "{\"additionalContext\": \"$context\"}"
+else
+  # No patterns detected, pass through without modification
+  echo "$original_input"
+fi

package/template/.claude/settings.json.example

@@ -0,0 +1,18 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "description": "Detect workflow patterns and suggest appropriate commands",
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".claude/hooks/workflow-detector.sh"
+          }
+        ]
+      }
+    ]
+  },
+  "tools": {
+    "enabled": true
+  }
+}

package/template/claude/CLAUDE.md

@@ -1,14 +1,16 @@
 # Claude Code Project Instructions
 
 ## Project Overview
-
+<!-- auto-generated-start:overview -->
 [Brief description of your project goes here]
+<!-- auto-generated-end:overview -->
 
 ## Key Objectives
-
+<!-- auto-generated-start:objectives -->
 - [Objective 1]
 - [Objective 2]
 - [Objective 3]
+<!-- auto-generated-end:objectives -->
 
 ## Project Structure
 
@@ -16,7 +18,8 @@
 .
 ├── CLAUDE.md          # This file - project instructions for Claude
 ├── .claude/           # Claude Code configuration (auto-generated)
-│   └── agents/        # Project-specific agent overrides
+│   ├── agents/        # Project-specific agent overrides
+│   └── commands/      # Custom slash commands for Claude Code
 ├── claude/            # Claude Code project organization
 │   ├── agents/        # Custom agents for specialized tasks
 │   ├── docs/          # Project documentation
@@ -45,14 +48,82 @@
 - Keep commits focused and atomic
 - Review changes before committing
 
-## Common Commands
+## Commit Convention and Pull Request Guidelines
+
+### Commit Message Format
+Follow the conventional commits specification:
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+**Types:**
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, missing semicolons, etc.)
+- `refactor`: Code refactoring without changing functionality
+- `test`: Adding or modifying tests
+- `chore`: Maintenance tasks (updating dependencies, build process, etc.)
+- `perf`: Performance improvements
+
+**Examples:**
+```
+feat(auth): add password reset functionality
+fix(api): handle null values in user response
+docs: update API documentation for book endpoints
+refactor(frontend): extract BookTable into separate components
+chore(deps): update FastAPI to 0.104.1
+```
+
+### Pull Request Guidelines
+
+**PR Title**: Use the same format as commit messages
 
+**PR Description Template:**
+```markdown
+## Summary
+Brief description of what this PR does and why it's needed.
+
+## Changes
+- List of specific changes made
+- Technical implementation details if relevant
+
+## Testing
+- [ ] Tests pass (if applicable)
+- [ ] Manual testing completed
+- [ ] No console errors or warnings
+
+## Manual Testing Steps
+1. Describe steps to manually test the feature
+2. Expected behavior and edge cases tested
+
+## Screenshots (if UI changes)
+Attach relevant screenshots here
+
+## Related Issues
+Closes #XXX (if applicable)
+
+## Checklist
+- [ ] Code follows project conventions
+- [ ] Self-documented code without unnecessary comments
+- [ ] All tests pass
+- [ ] Documentation updated if needed
+- [ ] No sensitive information exposed
+```
+
+## Common Commands
+<!-- auto-generated-start:commands -->
 ```bash
 # Add your common project commands here
 # npm install
 # npm run dev
 # npm test
 ```
+<!-- auto-generated-end:commands -->
 
 ## Important Context
 
@@ -66,6 +137,12 @@ See @claude/agents/README.md for available agents and their purposes
 
 After adding the agents you want to in `./claude/agents` folder, setup the workflow for Claude code to follow
 
+## Custom Commands
+
+Custom slash commands are available in `.claude/commands/`:
+- **/update-claude-md** - Automatically updates this file with project-specific information
+- See `.claude/commands/README.md` for creating your own commands
+
 ## Tickets
 
 See @claude/tickets/README.md for ticket format and management approach
@@ -100,5 +177,6 @@ Before starting any task:
 6. **Maintain ticket list**: Always update @claude/tickets/ticket-list.md when creating, updating, or completing tickets to maintain a clear project overview
 
 ## Additional Notes
-
-[Any other important information for Claude to know about this project]
+<!-- auto-generated-start:notes -->
+[Any other important information for Claude to know about this project]
+<!-- auto-generated-end:notes -->