claudeinone-cli 1.0.2 → 1.0.3

package/kit/.claude/skills/writing-technical.md

@@ -0,0 +1,119 @@
+# Technical Writing
+
+## Overview
+Write clear, accurate technical documentation — API docs, guides, tutorials, and READMEs that developers love.
+
+## README Structure
+
+```markdown
+# Project Name
+
+One-line description of what this does.
+
+## Features
+- ✅ Feature 1 — brief description
+- ✅ Feature 2 — brief description
+
+## Quick Start
+
+\`\`\`bash
+npm install my-package
+\`\`\`
+
+\`\`\`typescript
+import { MyThing } from 'my-package';
+const result = MyThing.doSomething({ option: true });
+\`\`\`
+
+## Installation
+Detailed installation with prerequisites.
+
+## Usage
+Code examples for common use cases.
+
+## API Reference
+Link to full API docs.
+
+## Contributing
+How to contribute — setup, tests, PRs.
+
+## License
+MIT
+```
+
+## API Documentation Pattern
+
+```typescript
+/**
+ * Fetches a user by their unique identifier.
+ *
+ * @param id - The UUID of the user to fetch
+ * @param options - Optional configuration
+ * @param options.includeProfile - Whether to include profile data (default: false)
+ * @returns The user object, or null if not found
+ * @throws {ValidationError} If the ID is not a valid UUID
+ * @throws {DatabaseError} If the database connection fails
+ *
+ * @example
+ * ```typescript
+ * const user = await getUser('550e8400-e29b-41d4-a716-446655440000');
+ * if (user) console.log(user.name);
+ * ```
+ */
+async function getUser(id: string, options?: { includeProfile?: boolean }): Promise<User | null> {
+  // implementation
+}
+```
+
+## Tutorial Writing Structure
+
+```markdown
+# How to Add Authentication to Your Next.js App
+
+## What you'll build
+A login/signup flow with JWT tokens.
+
+## Prerequisites
+- Node.js 18+
+- Basic React knowledge
+
+## Step 1: Install dependencies
+[Short explanation of why these packages are needed]
+\`\`\`bash
+npm install next-auth @auth/prisma-adapter
+\`\`\`
+
+## Step 2: Configure the provider
+[Explain what this code does, then show it]
+\`\`\`typescript
+// ...code...
+\`\`\`
+
+## Troubleshooting
+Common errors and how to fix them.
+
+## Next steps
+Links to related guides.
+```
+
+## Writing Guidelines
+
+```
+DO:
+✅ Use active voice: "Call the function" not "The function should be called"
+✅ Show complete, runnable code examples
+✅ Explain why, not just what
+✅ Use numbered steps for procedures
+✅ Include error messages users might see
+✅ Keep paragraphs to 3-4 sentences maximum
+
+DON'T:
+❌ Use jargon without defining it
+❌ Assume knowledge of unrelated topics
+❌ Write overly long intro paragraphs
+❌ Use "simply", "just", "easy" — it's condescending
+```
+
+## Resources
+- [Google Developer Style Guide](https://developers.google.com/style)
+- [Write the Docs](https://www.writethedocs.org)

package/kit/CLAUDE.md

@@ -0,0 +1,206 @@
+# ClaudeInOne Master System Prompt
+
+You are Claude, an expert AI assistant helping with the complete software development lifecycle using this production-grade framework.
+
+## Your Role
+
+You are a full-stack development expert with deep knowledge across:
+- Frontend frameworks (React, Next.js, Vue, Svelte, Astro)
+- Backend systems (.NET, Node.js, Python, Go)
+- Cloud platforms (AWS, GCP, Azure)
+- DevOps & Infrastructure (Docker, Kubernetes, Terraform)
+- Databases (Relational, NoSQL, Vector)
+- Security & Performance
+- Testing & Quality Assurance
+- AI/ML Integration
+
+## Working with ClaudeInOne
+
+This project includes 213+ production-ready skills covering all major development areas. Reference them in `.claude/skills/` when implementing features.
+
+### Command Structure
+
+All **ClaudeInOne** commands are namespaced under `/co:` to distinguish them from Claude Code's built-in commands (e.g. `/help`, `/clear`, `/init`).
+
+**Core workflow:**
+- `/co:bootstrap <description>` - Full project setup with planning and implementation
+- `/co:plan <feature>` - Create detailed implementation plan
+- `/co:cook <feature>` - Build feature end-to-end
+- `/co:fix <issue>` - Debug and fix issues
+- `/co:test` - Run tests and validate
+- `/co:review-codebase` - Full code review
+- `/co:docs-init` - Analyze and generate documentation
+- `/co:watzup` - Project status report
+
+**Quick reference by category:**
+- **Plan:** `/co:plan`, `/co:plan-fast`, `/co:plan-hard`, `/co:plan-parallel`
+- **Build:** `/co:cook`, `/co:bootstrap`, `/co:scaffold`, `/co:new-feature`
+- **Fix:** `/co:fix`, `/co:fix-fast`, `/co:fix-hard`, `/co:fix-ui`, `/co:fix-types`
+- **Review:** `/co:review-codebase`, `/co:review-security`, `/co:review-perf`, `/co:review-a11y`
+- **Test:** `/co:test`, `/co:test-gen`, `/co:test-ui`
+- **Git:** `/co:git-cm`, `/co:git-cp`, `/co:git-pr`, `/co:pr`
+- **Docs:** `/co:docs-init`, `/co:docs-update`, `/co:docs-readme`
+- **Deploy:** `/co:deploy`, `/co:docker`, `/co:k8s`, `/co:terraform`
+- **AI/Skills:** `/co:load`, `/co:skill-create`, `/co:use-mcp`
+
+## Session Workflow
+
+1. **Planning Phase**
+   - Clarify requirements
+   - Analyze codebase
+   - Create implementation plan
+   - Get user approval
+
+2. **Implementation Phase**
+   - Write code following established patterns
+   - Reference skills for best practices
+   - Handle errors gracefully
+   - Test incrementally
+
+3. **Verification Phase**
+   - Run full test suite
+   - Code review for quality
+   - Performance validation
+   - Documentation updates
+
+## Code Quality Standards
+
+### Language-Specific
+
+- **TypeScript/JavaScript**: Strict typing, no `any`, proper error handling
+- **Python**: Type hints, docstrings, PEP 8 compliance
+- **.NET/C#**: XML docs, SOLID principles, async/await patterns
+- **SQL**: Parameterized queries, proper indexing, query optimization
+
+### Architecture
+
+- Use appropriate design patterns (Factory, Observer, Strategy, etc.)
+- Dependency injection for testability
+- Separation of concerns (models, services, controllers)
+- Clear error boundaries
+
+### Security
+
+- Never log passwords or secrets
+- Use parameterized queries (SQL injection prevention)
+- Validate all user input
+- Escape output (XSS prevention)
+- Use HTTPS in production
+- Rotate secrets regularly
+
+### Performance
+
+- Database query optimization (indexes, N+1 prevention)
+- Caching strategies (Redis, in-memory)
+- Code splitting & lazy loading
+- Image optimization
+- Bundle size monitoring
+
+### Testing
+
+Aim for balanced coverage:
+- Unit tests: Business logic, utilities
+- Integration tests: API endpoints, database operations
+- E2E tests: Critical user flows
+- Accessibility tests: WCAG compliance
+
+## File Ownership
+
+When modifying code, take ownership of changes:
+- Maintain consistency with existing patterns
+- Update related tests
+- Update documentation
+- Consider backward compatibility
+
+## Token Budget
+
+- Budget: 200,000 tokens per session
+- Monitor token usage during long sessions
+- Prioritize essential work when approaching limits
+
+## Preferred Tools & Libraries
+
+### Frontend
+- React/Next.js (primary)
+- TypeScript (always)
+- Tailwind CSS (styling)
+- shadcn/ui (components)
+- Vitest (testing)
+
+### Backend
+- Node.js/Express or Next.js API routes
+- PostgreSQL/Prisma (primary)
+- Zod (validation)
+- Jest/Vitest (testing)
+
+### DevOps
+- Docker (containerization)
+- GitHub Actions (CI/CD)
+- Vercel (deployment)
+- Terraform (infrastructure)
+
+## When to Use Agents
+
+Spawn specialized agents for:
+- `/plan` - Multi-researcher planning
+- `/review:codebase` - Parallel reviewers
+- `cook` - Sequential team approach
+- Complex analysis or debugging
+
+## Important Rules
+
+- **DO**
+- Ask clarifying questions before starting
+- Create implementation plans for non-trivial changes
+- Write tests alongside code
+- Update documentation
+- Handle errors explicitly
+- Monitor performance impact
+
+- **DON'T**
+- Make destructive changes without confirmation
+- Commit code without user approval
+- Skip tests
+- Add unnecessary complexity
+- Log sensitive data
+- Use deprecated patterns
+
+## Project Structure
+
+```
+project/
+├── CLAUDE.md              # This file
+├── .claude/
+│   ├── skills/            # 128+ development skills
+│   ├── commands/          # Slash command definitions
+│   ├── agents/            # Specialized agents
+│   ├── settings.json      # Configuration
+│   └── .ck.json          # Version info
+├── src/
+├── tests/
+├── docs/
+└── plans/                 # Implementation plans
+```
+
+## Continuous Learning
+
+- Review `.claude/skills/` for implementation patterns
+- Check existing code before writing new code
+- Ask about project-specific conventions
+- Document decisions in plans/
+
+## Communication
+
+- Clear, concise responses
+- Show code changes with context
+- Explain architectural decisions
+- Flag potential issues early
+- Confirm before making risky changes
+
+---
+
+**Version**: 1.0.0
+**Framework**: ClaudeKit
+**Last Updated**: 2024-01-15
+
+For detailed guides on specific topics, reference the skills in `.claude/skills/`

package/kit/README.md

@@ -0,0 +1,150 @@
+# ClaudeInOne - Production-Grade Claude Code Framework
+
+A comprehensive development framework with 211+ production-ready skills, master system prompt, and best practices for building applications with Claude Code.
+
+## What's Included
+
+###  Skills Library (211 files)
+- Complete coverage of modern frameworks
+- Real, production-ready code examples
+- Best practices for each technology
+- Security & performance guidelines
+
+###  Master System Prompt (CLAUDE.md)
+- Complete developer guidelines
+- Code quality standards
+- Session workflow
+- Security & performance rules
+- Tool recommendations
+
+###  Configuration Files
+- `.ck.json` - Version and metadata
+- `settings.json` - Hooks and permissions
+- `.ckignore` - Exclusion patterns
+
+## Quick Start
+
+1. **Reference Skills** - Look up `.claude/skills/` for implementation patterns
+2. **Follow CLAUDE.md** - Guidelines for all development work
+3. **Use Commands** - Leverage slash commands in Claude Code
+4. **Build with Confidence** - Professional-grade best practices
+
+## Skills by Technology
+
+### Frameworks
+- Backend: .NET, Node.js, FastAPI, Spring Boot, gRPC
+- Frontend: React, Next.js, Vue, Svelte, Remix, Astro
+- Full-stack: Next.js, Remix, Astro
+
+### Databases
+- Relational: PostgreSQL, MySQL
+- NoSQL: MongoDB, Firebase
+- Search: Elasticsearch
+- Cache: Redis
+- Vector: Pinecone, Qdrant
+
+### Cloud Platforms
+- AWS (Lambda, S3, DynamoDB, RDS)
+- Google Cloud (Functions, Firestore, BigQuery)
+- Azure (Functions, Cosmos DB, SQL)
+- Vercel, Cloudflare, Railway, Render
+
+### DevOps
+- Containerization: Docker, Kubernetes
+- CI/CD: GitHub Actions, Jenkins, GitLab CI
+- Infrastructure: Terraform, CloudFormation
+- Monitoring: Prometheus, Grafana, DataDog
+
+### Testing
+- Unit: Jest, Vitest
+- E2E: Playwright, Cypress
+- Integration: Supertest
+- Performance: K6, Artillery
+- Load: JMeter, Locust
+
+### APIs
+- REST, GraphQL, tRPC
+- Webhooks, Real-time Subscriptions
+- Rate Limiting, Pagination
+
+### Architecture
+- Microservices, Event-Driven
+- CQRS, Clean Code
+- Design Patterns
+
+### AI/ML
+- LangChain, Gemini API
+- RAG, Vector Databases
+- Prompt Engineering
+
+### Security
+- Authentication (OAuth, JWT, WebAuthn)
+- Encryption, OWASP
+- Secrets Management
+
+## File Structure
+
+```
+claudekit/
+├── CLAUDE.md                    # Master system prompt
+├── SKILLS_INDEX.md              # Complete skills reference
+├── README.md                    # This file
+├── .claude/
+│   ├── skills/                  # 211+ production skills
+│   ├── commands/                # Slash command definitions
+│   ├── .ck.json                # Configuration
+│   ├── settings.json           # Settings
+│   └── .ckignore               # Ignore patterns
+└── docs/                        # Additional documentation
+```
+
+## Using with Claude Code
+
+1. **Read CLAUDE.md** - Understand guidelines and workflow
+2. **Reference Skills** - Use `.claude/skills/` for patterns
+3. **Use Slash Commands** - Available in Claude Code
+4. **Follow Best Practices** - Implement with quality standards
+
+## Key Features
+
+- **211 Production-Ready Skills** - Comprehensive technology coverage
+- **Real Code Examples** - Not templates, actual implementations
+- **Security First** - OWASP compliance throughout
+- **Performance Optimized** - Caching, database, bundle strategies
+- **Best Practices** - Industry-standard patterns
+- **Well-Organized** - Easy to find and reference
+- **Tested Patterns** - Proven implementations
+
+## Session Workflow
+
+1. **Planning** - Clarify requirements, analyze codebase
+2. **Implementation** - Write code following patterns
+3. **Verification** - Test, review, optimize
+
+## Code Quality Standards
+
+- **TypeScript/JavaScript** - Strict typing, no `any`
+- **Security** - Input validation, output escaping
+- **Performance** - Optimization, caching, monitoring
+- **Testing** - Comprehensive coverage
+- **Documentation** - Clear, maintainable code
+
+## Resources
+
+- CLAUDE.md - Complete system prompt
+- SKILLS_INDEX.md - Searchable skills directory
+- `.claude/skills/` - Implementation patterns
+- Official docs for each technology
+
+## Getting Started
+
+1. Read `CLAUDE.md` (5 min)
+2. Browse `SKILLS_INDEX.md` (10 min)
+3. Reference relevant skills as needed
+4. Follow best practices and guidelines
+
+---
+
+**Built with ClaudeInOne** - Your production-ready development framework
+
+Version 1.0.0 | 211 Skills | 100% Functional

package/kit/SKILLS_INDEX.md

@@ -0,0 +1,188 @@
+# ClaudeKit Skills Index
+
+## Complete Reference of 211 Production-Ready Skills
+
+### Backend Frameworks (15)
+- `backend-dotnet.md` - ASP.NET Core with Entity Framework
+- `backend-grpc.md` - gRPC with Protocol Buffers
+- `backend-websockets.md` - WebSocket server patterns
+- `backend-nodejs-express.md` - Node.js server patterns
+- `backend-fastapi.md` - Python FastAPI framework
+- `backend-spring.md` - Java Spring Boot
+
+### Databases & Storage (20)
+- `db-prisma.md` - Prisma ORM with TypeScript
+- `db-drizzle.md` - Drizzle ORM
+- `db-supabase.md` - Supabase PostgreSQL + real-time
+- `db-mongodb.md` - MongoDB NoSQL
+- `db-firebase-firestore.md` - Firebase real-time DB
+- `db-elasticsearch.md` - Elasticsearch search
+- `db-redis.md` - Redis caching & sessions
+- `db-postgresql.md` - PostgreSQL advanced patterns
+- `db-mysql.md` - MySQL optimization
+
+### Authentication (8)
+- `auth-nextauth.md` - NextAuth.js OAuth
+- `auth-lucia.md` - Lucia Auth for SvelteKit
+- `auth-oauth.md` - OAuth 2.0 & OpenID Connect
+- `auth-webauthn.md` - WebAuthn Passkeys
+- `auth-jwt.md` - JWT token management
+- `auth-session.md` - Session-based auth
+
+### Frontend Frameworks (12)
+- `web-nextjs.md` - Next.js 16 App Router
+- `web-nextjs-advanced.md` - Advanced patterns
+- `web-react.md` - React 19 patterns
+- `web-vue.md` - Vue 3 composition API
+- `web-svelte.md` - Svelte reactivity
+- `web-remix.md` - Remix full-stack
+- `web-astro.md` - Astro static generation
+- `web-htmx.md` - HTMX modern interactions
+- `web-html-css.md` - HTML5 & CSS fundamentals
+
+### UI & Styling (8)
+- `ui-shadcn.md` - shadcn/ui components
+- `styling-tailwind.md` - Tailwind CSS v4
+- `styling-css-modules.md` - CSS Modules scoping
+- `styling-styled-components.md` - CSS-in-JS
+
+### Cloud Platforms (12)
+- `cloud-aws.md` - AWS Lambda, S3, DynamoDB
+- `cloud-gcp.md` - Google Cloud Functions
+- `cloud-azure.md` - Azure Functions & Cosmos
+- `cloud-vercel.md` - Vercel edge functions
+- `cloud-cloudflare.md` - Cloudflare Workers
+- `cloud-railway.md` - Railway deployment
+- `cloud-render.md` - Render.com platform
+- `serverless-framework.md` - Serverless Framework
+- `infrastructure-serverless.md` - Serverless patterns
+
+### DevOps & Infrastructure (18)
+- `devops-docker.md` - Docker containerization
+- `devops-kubernetes.md` - Kubernetes orchestration
+- `devops-github-actions.md` - GitHub Actions CI/CD
+- `devops-terraform.md` - Infrastructure as Code
+- `devops-monitoring.md` - Prometheus & Grafana
+- `devops-logging.md` - Logging & aggregation
+- `devops-secrets.md` - Secrets management
+- `devops-ci-cd.md` - CI/CD pipeline patterns
+- `devops-health-checks.md` - Health monitoring
+- `devops-database-backup.md` - Backup & recovery
+- `infrastructure-docker-compose.md` - Multi-container setup
+
+### Testing (12)
+- `test-unit.md` - Jest unit testing
+- `test-e2e.md` - Playwright E2E testing
+- `test-integration.md` - Integration testing
+- `test-performance.md` - Performance testing
+- `test-tdd.md` - Test-driven development
+- `test-mutation.md` - Mutation testing
+- `testing-accessibility.md` - WCAG compliance
+- `testing-contract.md` - Contract testing
+- `testing-load-stress.md` - Load & stress testing
+- `testing-snapshot.md` - Snapshot testing
+
+### API Design (10)
+- `api-rest.md` - REST API best practices
+- `api-graphql.md` - GraphQL with Apollo
+- `api-trpc.md` - tRPC end-to-end type safety
+- `api-webhooks.md` - Webhooks & event delivery
+- `api-pagination-filtering.md` - Pagination patterns
+- `api-rate-limiting.md` - Rate limiting strategies
+- `api-rest-advanced.md` - Advanced REST patterns
+- `api-documentation.md` - OpenAPI/Swagger docs
+- `api-versioning.md` - API version management
+
+### Architecture Patterns (10)
+- `arch-microservices.md` - Microservices design
+- `arch-event-driven.md` - Event-driven systems
+- `arch-cqrs.md` - CQRS pattern
+- `arch-clean-code.md` - Clean architecture
+- `patterns-dependency-injection.md` - DI patterns
+- `patterns-factory-singleton.md` - Design patterns
+- `patterns-observer-pubsub.md` - Observer patterns
+
+### AI & Machine Learning (10)
+- `ai-langchain.md` - LangChain framework
+- `ai-gemini.md` - Google Gemini API
+- `ai-llamaindex.md` - LLamaIndex RAG
+- `ai-vectordb.md` - Vector databases
+- `ai-rag.md` - Retrieval-augmented generation
+- `ai-prompt-engineering.md` - Prompt optimization
+
+### Real-Time Features (5)
+- `realtime-subscriptions.md` - WebSockets & subscriptions
+- `messaging-rabbitmq.md` - RabbitMQ messaging
+- `messaging-kafka.md` - Apache Kafka streaming
+
+### Performance & Security (12)
+- `performance-optimization.md` - Code optimization
+- `performance-web-vitals.md` - Core Web Vitals
+- `database-optimization.md` - Query optimization
+- `performance-database-connection-pooling.md` - Connection pooling
+- `security-encryption.md` - Encryption & hashing
+- `security-owasp.md` - OWASP Top 10
+- `security-secrets-rotation.md` - Secrets rotation
+
+### Tools & Utilities (15)
+- `tooling-monorepo.md` - Turborepo/Nx
+- `tooling-testing-frameworks.md` - Test frameworks
+- `tooling-build-tools.md` - Vite, Webpack, ESBuild
+- `version-control-git.md` - Git workflows
+- `utilities-date-time.md` - Date handling
+- `nodejs-streams.md` - Stream processing
+- `data-csv-excel.md` - CSV/Excel handling
+
+### SaaS & Content (8)
+- `payment-stripe.md` - Stripe payments
+- `payment-square.md` - Square payments
+- `analytics-segment.md` - Segment analytics
+- `saas-user-onboarding.md` - User onboarding
+- `content-management.md` - CMS integration
+
+### Frontend Advanced (6)
+- `frontend-bundle-analysis.md` - Bundle optimization
+- `frontend-react-hooks.md` - Custom hooks
+- `frontend-state-management.md` - State management
+- `frontend-forms.md` - Form handling
+- `frontend-component-patterns.md` - Component design
+- `web-seo.md` - SEO optimization
+
+### Internationalization & Accessibility (3)
+- `i18n-localization.md` - Multi-language support
+- `web-accessibility-wcag.md` - WCAG standards
+- `frontend-caching.md` - Browser caching
+
+---
+
+## Skills by Category Usage
+
+**Quick Setup**: Use for project initialization
+**API Building**: REST, GraphQL, tRPC, Webhooks
+**Database**: Choose from 8+ database options
+**DevOps**: Complete CI/CD, Docker, Kubernetes
+**Frontend**: React, Next.js, Vue, Svelte, Astro
+**Testing**: Full coverage from unit to load testing
+**Security**: Auth, encryption, OWASP, secrets
+**Performance**: Optimization, caching, monitoring
+**AI/ML**: LangChain, RAG, Vector DBs
+**Real-time**: WebSockets, Kafka, RabbitMQ
+
+---
+
+## Total Coverage
+- **211 Production-Ready Skills**
+- **Real Code Examples** in every skill
+- **Best Practices** for each technology
+- **Error Handling** patterns included
+- **Security Considerations** throughout
+- **Resource Links** for deeper learning
+
+Every skill includes:
+* Setup instructions
+* Real, functional code
+* Common patterns
+* Best practices
+* Performance tips
+* Security measures
+* Resource references

package/kit/docs/README.md

@@ -0,0 +1,3 @@
+# ClaudeKit Docs
+
+Place generated architecture, API, and runbook documentation in this folder.

package/kit/journals/README.md

@@ -0,0 +1,3 @@
+# ClaudeKit Journals
+
+Session journals generated by `/journal` are stored here.

package/kit/plans/README.md

@@ -0,0 +1,3 @@
+# ClaudeKit Plans
+
+Store dated implementation plans in this folder.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeinone-cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Production-grade Claude Code framework — 213 skills, 37 agents, 95 /co: commands",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "smoke": "bash ./scripts/smoke.sh",
+    "prepack": "node ./scripts/materialize-kit.mjs",
+    "postpack": "node ./scripts/restore-kit-link.mjs",
     "dev": "bun run src/index.ts",
     "start": "node dist/index.js"
   },