ccstart 1.0.0

package/template/claude/agents/shadcn.md

@@ -0,0 +1,106 @@
+---
+name: shadcn
+description: shadcn/ui component library specialist. Use PROACTIVELY for building beautiful, accessible React interfaces with shadcn/ui, Radix UI, and Tailwind CSS. Invoke when implementing modern UI components with best-in-class accessibility.
+tools: Read, Write, Edit, Grep, Glob, Bash, WebSearch, WebFetch
+---
+
+You are a shadcn/ui specialist with deep expertise in building modern React interfaces using the shadcn/ui component library, Radix UI primitives, and Tailwind CSS. Your role is to create beautiful, accessible, and customizable user interfaces.
+
+## Core Responsibilities:
+1. **Component Implementation**: Build and customize shadcn/ui components
+2. **Theme Customization**: Implement custom themes and design systems
+3. **Accessibility**: Leverage Radix UI's built-in accessibility features
+4. **Integration**: Seamlessly integrate shadcn/ui into existing projects
+5. **Performance**: Optimize component bundles and rendering
+
+## Key Resources:
+- **Official Repository**: https://github.com/shadcn-ui/ui
+- **Documentation**: https://ui.shadcn.com
+- **Radix UI**: https://www.radix-ui.com
+- **Component Examples**: https://ui.shadcn.com/examples
+
+## Expertise Areas:
+
+### shadcn/ui Components:
+- **Forms**: Form, Input, Select, Checkbox, Radio, Switch, Textarea
+- **Overlays**: Dialog, Sheet, Popover, Tooltip, Context Menu
+- **Navigation**: Navigation Menu, Command, Menubar, Dropdown Menu
+- **Data Display**: Table, Data Table, Card, Badge, Avatar
+- **Feedback**: Alert, Toast, Progress, Skeleton, Spinner
+- **Layout**: Separator, Scroll Area, Aspect Ratio, Collapsible
+
+### Technical Foundation:
+- **Radix UI**: Unstyled, accessible component primitives
+- **Tailwind CSS**: Utility-first styling with custom configurations
+- **CVA**: Class variance authority for component variants
+- **TypeScript**: Full type safety for all components
+- **Lucide Icons**: Comprehensive icon library integration
+
+## Implementation Process:
+1. Install required dependencies (Radix UI, Tailwind, class-variance-authority)
+2. Set up Tailwind configuration with shadcn/ui presets
+3. Configure component library structure (components/ui)
+4. Copy or generate components using CLI or manual installation
+5. Customize theme variables in CSS/Tailwind config
+6. Implement component variants and compositions
+7. Ensure proper TypeScript types and props
+
+## shadcn/ui Philosophy:
+- **Copy-paste, not npm install**: Components live in your codebase
+- **Full customization**: Modify any aspect of components
+- **Accessibility first**: Built on Radix UI's accessible primitives
+- **Modern stack**: React, TypeScript, Tailwind CSS
+- **No vendor lock-in**: Own your component code
+
+## Customization Patterns:
+```typescript
+// Component variants with CVA
+const buttonVariants = cva(
+  "inline-flex items-center justify-center rounded-md text-sm font-medium",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-destructive-foreground",
+        outline: "border border-input bg-background hover:bg-accent",
+      },
+      size: {
+        default: "h-10 px-4 py-2",
+        sm: "h-9 rounded-md px-3",
+        lg: "h-11 rounded-md px-8",
+      },
+    },
+  }
+)
+```
+
+## Theme Configuration:
+- **CSS Variables**: Define colors, spacing, radii in :root
+- **Dark Mode**: Built-in dark mode support with Tailwind
+- **Custom Themes**: Create multiple theme variations
+- **Responsive Design**: Mobile-first with Tailwind utilities
+
+## Best Practices:
+- **Component Structure**: Keep ui components in components/ui
+- **Composition**: Build complex UIs by composing primitives
+- **Accessibility**: Never override Radix UI's accessibility features
+- **Customization**: Extend rather than override base styles
+- **Documentation**: Document custom variants and props
+
+## Common Integrations:
+- **React Hook Form**: Form validation and management
+- **Tanstack Table**: Advanced data table features
+- **Zod**: Schema validation for forms
+- **Next.js**: Server components and app directory
+- **Framer Motion**: Animations and transitions
+
+## Output Format:
+When implementing shadcn/ui solutions:
+- **Component Setup**: Installation commands and dependencies
+- **Implementation Code**: Complete component with all variants
+- **Usage Examples**: How to use the component in different scenarios
+- **Customization Guide**: How to modify for specific needs
+- **Accessibility Notes**: Key accessibility features preserved
+- **Integration Tips**: How to connect with forms, state, etc.
+
+Remember: shadcn/ui is about owning your components. Always prioritize customization, accessibility, and developer experience.

package/template/claude/docs/ROADMAP.md

@@ -0,0 +1,64 @@
+# ROADMAP
+
+## Overview
+
+High-level overview of the project, what it does, the main features
+
+## Development Workflow
+
+1. **Task Planning**
+   - Study the existing codebase and understand the current state
+   - Use the **planner** agent to break down complex problems and create implementation roadmaps
+   - Create a plan document in the `/plans` directory for complex features
+   - Update `ROADMAP.md` to include the new task under Development
+   - Priority tasks should be inserted after the last completed task
+
+2. **Ticket Creation**
+   - Study the existing codebase and understand the current state
+   - Create a new ticket file in the `/tickets` directory
+   - Name format: `TICKET-XXX-description.md` (e.g., `TICKET-001-user-auth.md`)
+   - Include high-level specifications, relevant files, acceptance criteria, and implementation steps
+   - Refer to last completed ticket in the `/tickets` directory for examples
+   - Note that completed tickets show checked boxes and summary of changes
+   - For new tickets, use empty checkboxes and no summary section
+
+3. **Task Implementation**
+   - Use the **coder** agent for implementing features, fixing bugs, and optimizing code
+   - Follow the specifications in the ticket file
+   - Implement features and functionality following project conventions
+   - Update step progress within the ticket file after each step
+   - Stop after completing each step and wait for further instructions
+
+4. **Quality Assurance**
+   - Use the **checker** agent for testing, security analysis, and code review
+   - Verify all acceptance criteria are met
+   - Run tests and ensure code quality standards
+   - Document any issues found and their resolutions
+
+5. **Roadmap Updates**
+   - Mark completed tasks with ✅ in the roadmap
+   - Add reference to the ticket file (e.g., `See: /tickets/TICKET-001-user-auth.md`)
+   - Update related plan documents if applicable
+
+## Development
+
+### Project Setup and Boilerplate
+- [x] Create Claude Code boilerplate structure ✅
+  - Set up CLAUDE.md with project instructions
+  - Create agents directory with planner, coder, and checker agents
+  - Establish docs, plans, and tickets directories
+  - Add README files to all directories
+
+### [Add your project tasks here]
+- [ ] Task description
+  - Subtask 1
+  - Subtask 2
+  - See: /tickets/TICKET-XXX-description.md
+
+## Future Enhancements
+
+[List potential future features and improvements]
+
+## Completed Tasks Archive
+
+[Move completed sections here to keep the active roadmap clean]

package/template/claude/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.

package/template/claude/plans/README.md

@@ -0,0 +1,53 @@
+# Plans
+
+This directory contains project plans and architectural documents.
+
+## Purpose
+Store detailed implementation plans, architectural decisions, and strategic roadmaps created by the planner agent or during project planning sessions.
+
+## Plan Structure
+Each plan should be a markdown file with:
+- Clear objectives and goals
+- Detailed implementation steps
+- Technical architecture decisions
+- Risk analysis and mitigation strategies
+- Success metrics
+
+## Example Plan Format
+```markdown
+# PLAN-XXX: [Plan Title]
+
+## Executive Summary
+[High-level overview]
+
+## Objectives
+- [ ] Objective 1
+- [ ] Objective 2
+
+## Architecture
+[Technical approach and design]
+
+## Implementation Phases
+### Phase 1: Foundation
+- Task 1
+- Task 2
+
+### Phase 2: Core Features
+- Task 3
+- Task 4
+
+## Risks & Mitigations
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| Risk 1 | High | Strategy 1 |
+
+## Success Metrics
+- Metric 1
+- Metric 2
+```
+
+## Plan Naming Convention
+Use format: `PLAN-XXX-brief-description.md`
+
+## Current Plans
+[List active plans here]

package/template/claude/tickets/README.md

@@ -0,0 +1,39 @@
+# Tickets
+
+This directory contains task tickets and issues.
+
+## Ticket Format
+Each ticket should be a markdown file with:
+- Clear title
+- Description of the task
+- Acceptance criteria
+- Priority level
+- Status
+
+## Example Ticket Structure
+```markdown
+# TICKET-001: [Title]
+
+## Description
+[Detailed description of the task]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Priority
+High/Medium/Low
+
+## Status
+Todo/In Progress/Done
+
+## Notes
+[Any additional context or notes]
+```
+
+## Ticket Naming Convention
+Use format: `TICKET-XXX-brief-description.md`
+
+## Current Tickets
+[List active tickets here]

package/template/claude/tickets/ticket-list.md

@@ -0,0 +1,79 @@
+# Ticket List
+
+## Overview
+This file maintains a centralized list of all tickets in the project. Update this file whenever you create, update, or complete tickets.
+
+**Note**: Individual ticket files are stored in this same `/tickets` folder with the naming convention `TICKET-XXX-description.md` (e.g., `TICKET-001-user-authentication.md`, `TICKET-002-api-integration.md`)
+
+## Ticket Status Legend
+- 🔴 **Todo** - Not started
+- 🟡 **In Progress** - Currently being worked on
+- 🟢 **Done** - Completed
+- 🔵 **Blocked** - Waiting on dependencies or external factors
+- ⚫ **Cancelled** - No longer needed
+
+## Active Tickets
+
+### High Priority
+_No high priority tickets yet_
+
+### Medium Priority
+_No medium priority tickets yet_
+
+### Low Priority
+_No low priority tickets yet_
+
+## Completed Tickets
+_No completed tickets yet_
+
+## Cancelled/Archived Tickets
+_No cancelled tickets yet_
+
+---
+
+## How to Use This File
+
+1. **When creating a new ticket**:
+   - Create the ticket file in `/tickets` folder (e.g., `TICKET-001-user-authentication.md`)
+   - Use the template structure from `/tickets/README.md` for the ticket content
+   - Add it to the appropriate priority section in this list
+   - Include ticket number, title, and status emoji
+   - Link to the full ticket file
+
+2. **Format for ticket entries**:
+   ```
+   - 🔴 [TICKET-001](./TICKET-001-user-authentication.md) - User Authentication System
+   ```
+   
+3. **File organization**:
+   ```
+   tickets/
+   ├── ticket-list.md          # This file (centralized index)
+   ├── TICKET-001-user-auth.md # Individual ticket file
+   ├── TICKET-002-api-docs.md  # Individual ticket file
+   └── TICKET-003-testing.md   # Individual ticket file
+   ```
+
+4. **When updating ticket status**:
+   - Change the status emoji
+   - Move completed tickets to "Completed Tickets" section
+   - Add completion date for completed tickets
+
+4. **Example of a populated list**:
+   ```markdown
+   ### High Priority
+   - 🟡 [TICKET-001](./TICKET-001-user-authentication.md) - User Authentication System
+   - 🔴 [TICKET-003](./TICKET-003-api-rate-limiting.md) - Implement API Rate Limiting
+
+   ### Medium Priority
+   - 🔵 [TICKET-002](./TICKET-002-email-notifications.md) - Email Notification Service (blocked: waiting for SMTP credentials)
+   
+   ### Completed Tickets
+   - 🟢 [TICKET-000](./TICKET-000-project-setup.md) - Initial Project Setup (Completed: 2024-01-15)
+   ```
+
+5. **Best Practices**:
+   - Keep this file updated in real-time
+   - Review weekly to ensure accuracy
+   - Use consistent naming conventions
+   - Archive old completed tickets quarterly