ccstart 2.0.0 → 2.1.0

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.1.0",
   "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/",