ccsetup 1.0.6 → 1.0.7

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "ccsetup",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Boilerplate for Claude Code projects with agents, tickets, and plans",
   "bin": {
-    "ccsetup": "./bin/create-project.js"
+    "ccsetup": "bin/create-project.js"
   },
-  "keywords": ["claude", "boilerplate", "project-template", "claude-code", "ai", "development"],
+  "keywords": [
+    "claude",
+    "boilerplate",
+    "project-template",
+    "claude-code",
+    "ai",
+    "development"
+  ],
   "author": "marcia_ong",
   "contributors": [
     "hima7459",
@@ -14,14 +21,26 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/MrMarciaOng/ccsetup.git"
+    "url": "git+https://github.com/MrMarciaOng/ccsetup.git"
   },
   "homepage": "https://github.com/MrMarciaOng/ccsetup#readme",
   "files": [
     "bin/",
-    "template/"
+    "template/",
+    "README.md"
   ],
   "engines": {
     "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "@inquirer/checkbox": "^4.0.4"
+  },
+  "devDependencies": {
+    "jest": "^30.0.5"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   }
-}
+}

package/template/.claude/README.md

@@ -0,0 +1,24 @@
+# .claude Directory
+
+This directory contains Claude Code configuration and project-specific resources.
+
+## Structure
+
+- **agents/** - Project-specific AI agents with custom prompts
+- **commands/** - Custom slash commands (created as needed)
+- **settings.json** - Shared project settings (created as needed)
+- **settings.local.json** - Personal settings (git-ignored, created as needed)
+
+## Agents
+
+The `agents/` directory contains specialized AI agents for your project. These agents are automatically available in Claude Code and can be invoked using the Task tool.
+
+To add a new agent:
+1. Create a markdown file in the `agents/` directory
+2. Follow the agent template structure
+3. The agent will be automatically available in Claude Code
+
+## Learn More
+
+For more information about Claude Code configuration, visit:
+https://docs.anthropic.com/claude-code/

package/template/.claude/agents/README.md

@@ -0,0 +1,44 @@
+# Claude Code Agents
+
+This directory contains project-specific AI agents that extend Claude Code's capabilities.
+
+## Using Agents
+
+Agents in this directory are automatically available in Claude Code. You can invoke them using the Task tool by specifying the agent type.
+
+## Agent Structure
+
+Each agent should be a markdown file with the following structure:
+
+```markdown
+---
+name: agent-name
+description: Brief description of what this agent does
+---
+
+# Agent Name
+
+## Purpose
+[What this agent does]
+
+## Capabilities
+- [Capability 1]
+- [Capability 2]
+
+## Instructions
+[Detailed instructions for the agent]
+```
+
+## Available Agents
+
+Agents will be listed here as they are added to this directory.
+
+## Creating Custom Agents
+
+To create a custom agent:
+1. Create a new `.md` file in this directory
+2. Add the frontmatter with name and description
+3. Define the agent's purpose, capabilities, and instructions
+4. The agent will be immediately available in Claude Code
+
+For more information about agents, see the main project's `agents/` directory.

package/template/CLAUDE.md

@@ -1,17 +1,22 @@
 # Claude Code Project Instructions
 
 ## Project Overview
+
 [Brief description of your project goes here]
 
 ## Key Objectives
+
 - [Objective 1]
 - [Objective 2]
 - [Objective 3]
 
 ## Project Structure
+
 ```
 .
 ├── CLAUDE.md          # This file - project instructions for Claude
+├── .claude/           # Claude Code configuration (auto-generated)
+│   └── agents/        # Project-specific agent overrides
 ├── agents/            # Custom agents for specialized tasks
 ├── docs/              # Project documentation
 ├── plans/             # Project plans and architectural documents
@@ -21,21 +26,25 @@
 ## Development Guidelines
 
 ### Code Style
+
 - Follow existing code conventions in the project
 - Use consistent naming patterns
 - Maintain clean, readable code
 
 ### Testing
+
 - Run tests before committing changes
 - Add tests for new functionality
 - Ensure all tests pass
 
 ### Git Workflow
+
 - Create descriptive commit messages
 - Keep commits focused and atomic
 - Review changes before committing
 
 ## Common Commands
+
 ```bash
 # Add your common project commands here
 # npm install
@@ -44,18 +53,26 @@
 ```
 
 ## Important Context
+
 [Add any project-specific context, dependencies, or requirements here]
 
 ## Agents
+
 See @agents/README.md for available agents and their purposes
 
+## Agent Orchestration
+
+After adding the agents you want to in `./claude/agents` folder, setup the workflow for Claude code to follow
+
 ## Tickets
+
 See @tickets/README.md for ticket format and management approach
 
 ## Plans
+
 See @plans/README.md for planning documents and architectural decisions
 
-## Development Context 
+## Development Context
 
 - See @docs/ROADMAP.md for current status and next steps
 - Task-based development workflow with tickets in `/tickets` directory
@@ -64,6 +81,7 @@ See @plans/README.md for planning documents and architectural decisions
 ## Important Instructions
 
 Before starting any task:
+
 1. **Confirm understanding**: Always confirm you understand the request and outline your plan before proceeding
 2. **Ask clarifying questions**: Never make assumptions - ask questions when requirements are unclear
 3. **Create planning documents**: Before implementing any code or features, create a markdown file documenting the approach
@@ -71,4 +89,5 @@ Before starting any task:
 5. **No code comments**: Never add comments to any code you write - code should be self-documenting
 
 ## Additional Notes
-[Any other important information for Claude to know about this project]
+
+[Any other important information for Claude to know about this project]

package/template/agents/backend.md

@@ -0,0 +1,80 @@
+---
+name: backend
+description: Backend development specialist. Use PROACTIVELY for API design, database architecture, authentication, microservices, and server-side optimization. Invoke when building APIs, services, or backend infrastructure.
+tools: Read, Write, Edit, Grep, Glob, Bash, WebSearch, WebFetch
+---
+
+You are a senior backend engineer with expertise in server-side technologies and distributed systems. Your role is to design and implement scalable, secure, and performant backend services.
+
+## Core Responsibilities:
+1. **API Design**: Create RESTful and GraphQL APIs with proper documentation
+2. **Database Architecture**: Design efficient schemas and optimize queries
+3. **Authentication & Security**: Implement secure auth flows and data protection
+4. **Microservices**: Build scalable, distributed service architectures
+5. **Performance & Scaling**: Ensure high availability and optimal response times
+
+## Expertise Areas:
+
+### Languages & Frameworks:
+- **Node.js**: Express, Fastify, NestJS, middleware patterns
+- **Python**: Django, FastAPI, Flask, async programming
+- **Java**: Spring Boot, microservices, reactive programming
+- **Go**: High-performance services, concurrent programming
+- **Ruby**: Rails, API-only applications, background jobs
+
+### Technical Skills:
+- **Databases**: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch
+- **Message Queues**: RabbitMQ, Kafka, Redis Pub/Sub, AWS SQS
+- **Caching**: Redis, Memcached, CDN strategies
+- **Testing**: Unit, integration, load testing, TDD/BDD
+- **DevOps**: Docker, Kubernetes, CI/CD, monitoring
+
+## Development Process:
+1. Analyze requirements and define API contracts
+2. Design database schema and relationships
+3. Implement service layer with business logic
+4. Create comprehensive error handling
+5. Add authentication and authorization
+6. Optimize queries and implement caching
+7. Write thorough tests and documentation
+
+## Best Practices:
+- **API Design**: RESTful principles, versioning, consistent responses
+- **Security**: Input validation, SQL injection prevention, rate limiting
+- **Performance**: Query optimization, connection pooling, caching strategies
+- **Scalability**: Horizontal scaling, load balancing, stateless design
+- **Error Handling**: Graceful degradation, meaningful error messages
+- **Monitoring**: Logging, metrics, distributed tracing
+
+## Architecture Patterns:
+- **Microservices**: Service boundaries, API gateway, service mesh
+- **Event-Driven**: Event sourcing, CQRS, message-driven architecture
+- **Serverless**: Lambda functions, edge computing, FaaS patterns
+- **Monolithic**: When appropriate, modular monoliths
+- **Database**: Repository pattern, unit of work, migrations
+
+## Security Considerations:
+- Authentication: JWT, OAuth2, session management
+- Authorization: RBAC, ABAC, policy engines
+- Data Protection: Encryption at rest and in transit
+- API Security: Rate limiting, CORS, input sanitization
+- Compliance: GDPR, PCI DSS, HIPAA considerations
+
+## Performance Optimization:
+- **Database**: Indexing, query optimization, connection pooling
+- **Caching**: Multi-level caching, cache invalidation strategies
+- **Async Processing**: Background jobs, message queues
+- **Load Balancing**: Round-robin, least connections, health checks
+- **Monitoring**: APM tools, custom metrics, alerting
+
+## Output Format:
+Structure backend solutions with:
+- **Architecture Overview**: Service boundaries and interactions
+- **API Documentation**: Endpoints, request/response formats
+- **Database Schema**: Tables, relationships, indexes
+- **Implementation**: Clean, maintainable service code
+- **Security Measures**: Auth flow and data protection
+- **Performance Strategy**: Caching, optimization techniques
+- **Deployment Plan**: Infrastructure and scaling approach
+
+Remember: Backend services are the foundation. Focus on reliability, security, and scalability in every implementation.

package/template/docs/agent-orchestration.md

@@ -0,0 +1,152 @@
+# Agent Orchestration Guide
+
+## Overview
+This document defines the standard workflows for orchestrating multiple agents in Claude Code to complete complex tasks efficiently. Follow these patterns to ensure consistent and thorough task execution.
+
+## Core Agent Workflows
+
+### 1. Feature Development Workflow
+**Purpose**: Implement new features from conception to completion
+
+**Flow**:
+1. **Researcher Agent** → Gather requirements and understand existing codebase
+2. **Planner Agent** → Create detailed implementation plan and architecture
+3. **Coder Agent** → Implement the feature following the plan
+4. **Checker Agent** → Test, review, and validate the implementation
+
+**Example Prompt**:
+```
+"I need to add user authentication to the app. First use the researcher agent to understand the current architecture, then the planner to design the auth system, coder to implement it, and checker to validate."
+```
+
+### 2. Bug Fix Workflow
+**Purpose**: Systematically identify and fix bugs
+
+**Flow**:
+1. **Researcher Agent** → Investigate the bug and find root cause
+2. **Coder Agent** → Implement the fix
+3. **Checker Agent** → Verify fix and check for regressions
+
+### 3. Refactoring Workflow
+**Purpose**: Improve code quality without changing functionality
+
+**Flow**:
+1. **Researcher Agent** → Analyze current implementation and identify improvements
+2. **Planner Agent** → Design refactoring approach
+3. **Coder Agent** → Execute refactoring
+4. **Checker Agent** → Ensure functionality remains intact
+
+### 4. API Development Workflow
+**Purpose**: Design and implement APIs
+
+**Flow**:
+1. **Planner Agent** → Design API architecture and endpoints
+2. **Backend Agent** → Implement server-side logic
+3. **Frontend Agent** → Create client integration (if needed)
+4. **Checker Agent** → Test API functionality and security
+
+### 5. UI Component Workflow
+**Purpose**: Create user interface components
+
+**Flow**:
+1. **Frontend Agent** → Design and implement UI components
+2. **Shadcn Agent** → Apply shadcn/ui styling (if using React)
+3. **Checker Agent** → Test accessibility and responsiveness
+
+### 6. Blockchain Development Workflow
+**Purpose**: Develop Web3 features and smart contracts
+
+**Flow**:
+1. **Planner Agent** → Design smart contract architecture
+2. **Blockchain Agent** → Implement contracts and Web3 integration
+3. **Checker Agent** → Security audit and testing
+
+## Orchestration Best Practices
+
+### 1. Always Start with Understanding
+- Use Researcher Agent first for non-trivial tasks
+- Understand existing code before making changes
+- Document findings in plans directory
+
+### 2. Plan Before Implementation
+- Use Planner Agent for complex features
+- Create detailed plans in `/plans` directory
+- Break down large tasks into smaller tickets
+
+### 3. Sequential Execution
+- Complete each agent's task before moving to the next
+- Use TodoWrite to track progress through the workflow
+- Don't skip agents unless explicitly instructed
+
+### 4. Validation is Mandatory
+- Always end with Checker Agent
+- Run tests and linting
+- Verify all acceptance criteria
+
+### 5. Documentation Updates
+- Update ROADMAP.md after completing workflows
+- Mark tickets as complete with summaries
+- Keep plans updated with outcomes
+
+## Workflow Triggers
+
+### When to use Feature Development Workflow:
+- Adding new functionality
+- Implementing user stories
+- Creating new modules or services
+
+### When to use Bug Fix Workflow:
+- Fixing reported issues
+- Addressing error messages
+- Resolving unexpected behavior
+
+### When to use Refactoring Workflow:
+- Improving code readability
+- Optimizing performance
+- Updating deprecated code
+
+### When to use API Development Workflow:
+- Creating new endpoints
+- Designing service interfaces
+- Building integrations
+
+### When to use UI Component Workflow:
+- Building new UI elements
+- Updating existing interfaces
+- Implementing design changes
+
+### When to use Blockchain Workflow:
+- Smart contract development
+- DeFi integrations
+- Web3 features
+
+## Example Multi-Agent Execution
+
+```
+User: "I need to add a payment processing feature"
+
+Claude's Response Flow:
+1. "I'll help you add payment processing. Let me start by using the researcher agent to understand your current architecture and any existing payment-related code."
+   [Uses Researcher Agent]
+
+2. "Based on my research, I'll now use the planner agent to design the payment processing system."
+   [Uses Planner Agent, creates plan in /plans]
+
+3. "With the plan ready, I'll use the backend agent to implement the server-side payment processing."
+   [Uses Backend Agent]
+
+4. "Now I'll use the frontend agent to create the payment UI components."
+   [Uses Frontend Agent]
+
+5. "Finally, let me use the checker agent to verify the implementation and ensure security."
+   [Uses Checker Agent]
+```
+
+## Workflow Customization
+
+You can create custom workflows by:
+1. Combining agents in different sequences
+2. Adding conditional paths based on findings
+3. Creating specialized workflows for your project
+
+Remember: The goal is systematic, thorough task completion with proper validation at each step.