@smicolon/ai-kit 0.1.0 → 0.2.0

package/packs/flutter/skills/flutter-architecture/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: flutter-architecture
+description: >-
+  Provides Flutter app architecture patterns with feature-first structure, clean architecture,
+  and state management (Bloc, Riverpod, Provider). Use when user asks about Flutter project
+  structure, state management selection, dependency injection, or designing Flutter app architecture.
+version: 1.0.0
+---
+
+# Flutter Architecture Patterns
+
+Apply these patterns when designing or implementing Flutter applications.
+
+## Feature-First Project Structure
+
+Organize Flutter projects by feature, not by layer:
+
+```
+lib/
+├── core/                          # Shared infrastructure
+│   ├── constants/                 # App-wide constants
+│   ├── errors/                    # Error classes and handling
+│   ├── extensions/                # Dart extensions
+│   ├── network/                   # HTTP client, interceptors
+│   ├── theme/                     # App theme, colors, typography
+│   └── utils/                     # Utility functions
+├── features/                      # Feature modules
+│   ├── auth/
+│   │   ├── data/                  # Data layer
+│   │   │   ├── datasources/       # Remote and local data sources
+│   │   │   ├── models/            # Data models (JSON serializable)
+│   │   │   └── repositories/      # Repository implementations
+│   │   ├── domain/                # Domain layer
+│   │   │   ├── entities/          # Business entities
+│   │   │   ├── repositories/      # Repository interfaces
+│   │   │   └── usecases/          # Business logic
+│   │   └── presentation/          # UI layer
+│   │       ├── bloc/              # State management
+│   │       ├── pages/             # Screen widgets
+│   │       └── widgets/           # Feature-specific widgets
+│   └── [other_features]/
+├── shared/                        # Shared UI components
+│   ├── widgets/                   # Reusable widgets
+│   └── services/                  # Shared services
+└── main.dart
+```
+
+## Clean Architecture Layers
+
+### Dependency Rule
+- Presentation → Domain ← Data
+- Domain has NO external dependencies
+- Data implements Domain interfaces
+
+### Layer Responsibilities
+
+**Presentation**: UI components, state management, user interaction handling
+**Domain**: Business entities, use cases, repository contracts
+**Data**: API calls, local storage, data transformation
+
+## State Management Selection
+
+### Use Bloc When:
+- Building enterprise applications
+- Need explicit state transitions
+- Complex business logic with multiple states
+- Team prefers reactive programming patterns
+
+### Use Riverpod When:
+- Want compile-time safety for providers
+- Need flexible dependency injection
+- Building modern, testable applications
+- Auto-dispose of resources is important
+
+### Use Provider When:
+- Building simpler applications
+- Team is new to Flutter
+- Don't need complex state management
+- Rapid prototyping
+
+## Key Dependencies
+
+```yaml
+dependencies:
+  # State Management (choose one)
+  flutter_bloc: ^8.1.0      # Bloc
+  flutter_riverpod: ^2.4.0  # Riverpod
+  provider: ^6.1.0          # Provider
+
+  # Dependency Injection
+  get_it: ^7.6.0
+  injectable: ^2.3.0
+
+  # Navigation
+  go_router: ^13.0.0
+
+  # Networking
+  dio: ^5.4.0
+
+  # Code Generation
+  freezed_annotation: ^2.4.0
+  json_annotation: ^4.8.0
+
+dev_dependencies:
+  build_runner: ^2.4.0
+  freezed: ^2.4.0
+  json_serializable: ^6.7.0
+  injectable_generator: ^2.4.0
+
+  # Testing
+  bloc_test: ^9.1.0
+  mocktail: ^1.0.0
+```
+
+## Quick Reference
+
+| Aspect | Recommendation |
+|--------|----------------|
+| Structure | Feature-first |
+| State | Bloc (enterprise), Riverpod (modern), Provider (simple) |
+| DI | get_it + injectable |
+| Navigation | go_router |
+| HTTP | Dio |
+| Immutability | Freezed |
+| Testing | mocktail + bloc_test |
+
+For detailed implementation examples, consult the flutter-architect agent.

package/packs/flutter/skills/store-publishing/SKILL.md

@@ -0,0 +1,163 @@
+---
+name: store-publishing
+description: >-
+  Provides App Store and Google Play publishing requirements, metadata management,
+  screenshot specifications, review guidelines, and compliance requirements.
+  Use when user asks about publishing apps, store requirements, app review, or store metadata.
+version: 1.0.0
+---
+
+# Store Publishing Guide
+
+Requirements and best practices for App Store and Google Play publishing.
+
+## App Store Connect (iOS)
+
+### Required Metadata
+- App name (30 characters max)
+- Subtitle (30 characters max)
+- Description (4000 characters max)
+- Keywords (100 characters, comma-separated)
+- Support URL
+- Marketing URL (optional)
+- Privacy Policy URL (required)
+
+### Screenshots Required
+
+| Device | Size | Required |
+|--------|------|----------|
+| iPhone 6.7" | 1290 x 2796 | Yes |
+| iPhone 6.5" | 1284 x 2778 | Yes |
+| iPhone 5.5" | 1242 x 2208 | Optional |
+| iPad Pro 12.9" | 2048 x 2732 | If iPad supported |
+
+### App Review Guidelines
+- No placeholder content
+- Complete functionality
+- Accurate screenshots
+- Clear privacy policy
+- No hidden features
+- Proper age rating
+
+### Common Rejection Reasons
+1. Incomplete information
+2. Bugs or crashes
+3. Placeholder content
+4. Misleading screenshots
+5. Privacy policy issues
+6. Guideline 4.2 (minimum functionality)
+
+## Google Play Console (Android)
+
+### Required Metadata
+- App name (50 characters max)
+- Short description (80 characters max)
+- Full description (4000 characters max)
+- Application type
+- Category
+- Content rating
+- Privacy policy URL
+
+### Graphics Required
+
+| Asset | Size | Format |
+|-------|------|--------|
+| App icon | 512 x 512 | PNG (32-bit) |
+| Feature graphic | 1024 x 500 | PNG/JPEG |
+| Phone screenshots | 16:9 or 9:16 | PNG/JPEG |
+| Tablet screenshots | 16:9 or 9:16 | If tablet supported |
+
+### Release Tracks
+
+| Track | Purpose | Review |
+|-------|---------|--------|
+| Internal | Team testing | No review |
+| Closed | Limited testers | No review |
+| Open | Public beta | Light review |
+| Production | Public release | Full review |
+
+### Data Safety Declaration
+Required information about:
+- Data collection practices
+- Data sharing
+- Security practices
+- Data deletion options
+
+## Pre-Submission Checklist
+
+### iOS
+- [ ] App icon (1024x1024)
+- [ ] Screenshots for required devices
+- [ ] Privacy policy URL accessible
+- [ ] App description complete
+- [ ] Keywords optimized
+- [ ] Age rating set
+- [ ] In-app purchases configured (if any)
+- [ ] Export compliance answered
+
+### Android
+- [ ] App icon (512x512)
+- [ ] Feature graphic
+- [ ] Screenshots uploaded
+- [ ] Privacy policy URL
+- [ ] Content rating questionnaire completed
+- [ ] Data safety form completed
+- [ ] Target API level compliance
+- [ ] App signing by Google Play enabled
+
+## Store Listing Best Practices
+
+### App Name
+- Include main keyword
+- Keep concise and memorable
+- Avoid generic terms
+
+### Description
+- First 1-2 lines most important
+- Include key features
+- Use bullet points
+- Add call to action
+- Include keywords naturally
+
+### Screenshots
+- Show actual app screens
+- Add captions/overlays
+- Highlight key features
+- Use consistent style
+- First screenshot most important
+
+## Version Management
+
+### Semantic Versioning
+```
+MAJOR.MINOR.PATCH+BUILD
+1.2.3+45
+```
+
+### iOS Build Numbers
+- Must increment for each upload
+- Use CI build number
+
+### Android Version Codes
+- Integer, must increment
+- Use formula: `MAJOR*10000 + MINOR*100 + PATCH`
+
+## Release Notes Template
+
+```markdown
+## What's New in Version X.Y.Z
+
+### New Features
+- Feature 1 description
+- Feature 2 description
+
+### Improvements
+- Improvement 1
+- Improvement 2
+
+### Bug Fixes
+- Fixed issue with...
+- Resolved crash when...
+```
+
+For automated store submissions, use the `/flutter-deploy` command.

package/packs/hono/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "hono",
+  "version": "0.1.0",
+  "description": "Hono web framework plugin for Claude Code - scaffolding, conventions, testing, and deployment for Bun and Cloudflare Workers",
+  "author": {
+    "name": "Smicolon",
+    "email": "dev@smicolon.com"
+  },
+  "repository": "https://github.com/smicolon/ai-kit",
+  "license": "MIT",
+  "keywords": [
+    "hono",
+    "bun",
+    "cloudflare-workers",
+    "edge",
+    "typescript",
+    "api"
+  ]
+}

package/packs/hono/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to the smi-hono plugin will be documented in this file.
+
+## [Unreleased]
+
+### Changed
+- Renamed from `smi-hono` to `hono` as part of ai-kit migration
+- Moved from `plugins/smi-hono/` to `packs/hono/`
+
+## [0.1.0] - 2025-01-02
+
+### Added
+- Initial release (experimental)
+- 4 agents: hono-architect, hono-builder, hono-tester, hono-reviewer
+- 4 commands: route-create, middleware-create, project-init, rpc-client
+- 4 skills: hono-patterns, cloudflare-bindings, zod-validation, rpc-typesafe
+- Support for Bun and Cloudflare Workers
+- Type-safe RPC client generation

package/packs/hono/README.md

@@ -0,0 +1,143 @@
+# hono
+
+Claude Code plugin for **Hono** - the ultrafast web framework for the Edge. Provides scaffolding, conventions, testing, and deployment support for Bun and Cloudflare Workers.
+
+## Features
+
+- **4 Specialized Agents** for architecture, building, testing, and code review
+- **4 Commands** for scaffolding routes, middleware, projects, and RPC clients
+- **4 Auto-activating Skills** for Hono patterns, CF Workers bindings, Zod validation, and RPC
+- **Convention Enforcement** via hooks
+
+## Installation
+
+```bash
+# Add Smicolon marketplace (if not already added)
+/plugin marketplace add https://github.com/smicolon/ai-kit
+
+# Install the plugin
+/plugin install hono
+```
+
+## Agents
+
+| Agent | Description |
+|-------|-------------|
+| `@hono-architect` | Design API architecture, project structure, routing organization |
+| `@hono-builder` | Implement features, routes, middleware, handlers |
+| `@hono-tester` | Write tests using Bun test or Vitest for CF Workers |
+| `@hono-reviewer` | Security review, best practices, performance audit |
+
+### Usage
+
+```bash
+@hono-architect "Design a REST API for user management with authentication"
+@hono-builder "Implement the /users routes with CRUD operations"
+@hono-tester "Write tests for the user service"
+@hono-reviewer "Review the authentication middleware for security issues"
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/route-create` | Create new routes with handlers, validators, and types |
+| `/middleware-create` | Create custom middleware with proper typing |
+| `/project-init` | Initialize a new Hono project (Bun/CF Workers) |
+| `/rpc-client` | Generate type-safe RPC client from server routes |
+
+### Usage
+
+```bash
+/route-create
+/middleware-create
+/project-init
+/rpc-client
+```
+
+## Skills (Auto-activating)
+
+These skills automatically activate based on context:
+
+| Skill | Triggers When |
+|-------|---------------|
+| `hono-patterns` | Writing Hono routes, handlers, middleware |
+| `cloudflare-bindings` | Working with KV, D1, R2, Durable Objects |
+| `zod-validation` | Form/JSON validation in Hono handlers |
+| `rpc-typesafe` | Setting up type-safe client-server communication |
+
+## Conventions Enforced
+
+### Project Structure
+
+```
+src/
+├── routes/           # Route handlers organized by resource
+│   ├── users.ts
+│   └── posts.ts
+├── middleware/       # Custom middleware
+│   ├── auth.ts
+│   └── logger.ts
+├── validators/       # Zod schemas
+│   └── user.schema.ts
+├── types/            # TypeScript types
+│   └── bindings.ts
+├── lib/              # Shared utilities
+└── index.ts          # App entry point
+```
+
+### Import Pattern
+
+```typescript
+// Named imports (standard Hono style)
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import { cors } from 'hono/cors'
+```
+
+### Handler Pattern
+
+```typescript
+// Use factory pattern for typed handlers
+import { createFactory } from 'hono/factory'
+
+const factory = createFactory<{ Bindings: Env }>()
+
+export const getUser = factory.createHandlers(
+  zValidator('param', z.object({ id: z.string().uuid() })),
+  async (c) => {
+    const { id } = c.req.valid('param')
+    // ...
+  }
+)
+```
+
+### Type-Safe Bindings
+
+```typescript
+// types/bindings.ts
+export type Env = {
+  Bindings: {
+    DB: D1Database
+    KV: KVNamespace
+    BUCKET: R2Bucket
+    API_KEY: string
+  }
+  Variables: {
+    user: User
+  }
+}
+```
+
+## Supported Platforms
+
+- **Bun** (primary development runtime)
+- **Cloudflare Workers** (primary deployment target)
+- **Deno**
+- **Node.js**
+
+## Requirements
+
+- Bun >= 1.0
+- TypeScript >= 5.0
+- Wrangler (for Cloudflare Workers deployment)

package/packs/hono/agents/hono-architect.md

@@ -0,0 +1,240 @@
+---
+name: hono-architect
+description: Senior Hono architect for designing Edge-first API architecture with TypeScript, Zod validation, and multi-platform support (Bun, Cloudflare Workers).
+model: inherit
+skills:
+  - hono-patterns
+  - cloudflare-bindings
+  - rpc-typesafe
+---
+
+# Hono Architect
+
+You are a senior Hono architect specializing in Edge-first API design.
+
+## Current Task
+Analyze the request and provide architectural guidance for Hono API development.
+
+## Tech Stack Context
+- **Framework**: Hono (ultrafast Edge framework)
+- **Primary Runtime**: Bun
+- **Deployment**: Cloudflare Workers
+- **Language**: TypeScript (strict mode)
+- **Validation**: Zod + @hono/zod-validator
+- **Client**: hc (type-safe RPC client)
+
+## Your Role
+
+1. **Analyze Requirements**: Understand the API domain
+2. **Design Route Structure**: Plan modular routing with `app.route()`
+3. **Design Types**: Plan TypeScript types and Zod schemas
+4. **Plan Middleware**: Identify authentication, logging, CORS needs
+5. **Design Bindings**: Plan Cloudflare KV, D1, R2 usage
+6. **Plan RPC**: Design type-safe client-server communication
+
+## Architecture Principles
+
+### Project Structure
+
+```
+src/
+├── routes/              # Route handlers organized by resource
+│   ├── users.ts         # /api/users routes
+│   ├── posts.ts         # /api/posts routes
+│   └── index.ts         # Route aggregator
+├── middleware/          # Custom middleware
+│   ├── auth.ts          # Authentication
+│   ├── logger.ts        # Request logging
+│   └── index.ts         # Barrel export
+├── validators/          # Zod schemas
+│   ├── user.schema.ts
+│   └── post.schema.ts
+├── types/               # TypeScript types
+│   ├── bindings.ts      # CF Worker bindings
+│   └── api.ts           # API types
+├── lib/                 # Shared utilities
+│   ├── errors.ts        # Custom errors
+│   └── utils.ts         # Helpers
+└── index.ts             # App entry point
+```
+
+### Bindings Type Definition
+
+```typescript
+// types/bindings.ts
+export type Env = {
+  Bindings: {
+    // Cloudflare bindings
+    DB: D1Database
+    KV: KVNamespace
+    BUCKET: R2Bucket
+    // Environment variables
+    API_KEY: string
+    JWT_SECRET: string
+  }
+  Variables: {
+    // Request-scoped variables set by middleware
+    user: User
+    requestId: string
+  }
+}
+```
+
+### Route Organization
+
+```typescript
+// routes/users.ts
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import type { Env } from '../types/bindings'
+import { createUserSchema, updateUserSchema } from '../validators/user.schema'
+
+const users = new Hono<Env>()
+
+users.get('/', async (c) => {
+  const db = c.env.DB
+  const users = await db.prepare('SELECT * FROM users').all()
+  return c.json(users.results)
+})
+
+users.post('/',
+  zValidator('json', createUserSchema),
+  async (c) => {
+    const data = c.req.valid('json')
+    // Create user logic
+    return c.json({ id: 'uuid', ...data }, 201)
+  }
+)
+
+export { users }
+```
+
+### App Composition
+
+```typescript
+// index.ts
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { logger } from 'hono/logger'
+import type { Env } from './types/bindings'
+import { users } from './routes/users'
+import { posts } from './routes/posts'
+import { authMiddleware } from './middleware/auth'
+
+const app = new Hono<Env>()
+
+// Global middleware
+app.use('*', logger())
+app.use('*', cors())
+
+// Protected routes
+app.use('/api/*', authMiddleware)
+
+// Mount routes
+app.route('/api/users', users)
+app.route('/api/posts', posts)
+
+// Health check
+app.get('/health', (c) => c.json({ status: 'ok' }))
+
+export default app
+
+// Export type for RPC client
+export type AppType = typeof app
+```
+
+### RPC Client Setup
+
+```typescript
+// client.ts
+import { hc } from 'hono/client'
+import type { AppType } from './index'
+
+const client = hc<AppType>('http://localhost:8787')
+
+// Type-safe API calls
+const res = await client.api.users.$get()
+const users = await res.json()
+```
+
+## Deliverables
+
+Provide a comprehensive architecture document:
+
+1. **Route Structure**
+   - All endpoints with HTTP methods
+   - Request/response formats
+   - Authentication requirements
+
+2. **Type Definitions**
+   - Env bindings type
+   - API request/response types
+   - Zod validation schemas
+
+3. **Middleware Stack**
+   - Authentication strategy
+   - Logging and monitoring
+   - Error handling
+
+4. **Database Design** (if using D1)
+   - Table schemas
+   - Indexes
+   - Migrations approach
+
+5. **Caching Strategy** (if using KV)
+   - Cache keys
+   - TTL policies
+   - Invalidation approach
+
+6. **File Storage** (if using R2)
+   - Bucket organization
+   - Access patterns
+   - URL generation
+
+## Code Examples
+
+Provide example code showing:
+
+```typescript
+// Example: Complete route with validation
+import { Hono } from 'hono'
+import { zValidator } from '@hono/zod-validator'
+import { z } from 'zod'
+import type { Env } from '../types/bindings'
+
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+})
+
+const users = new Hono<Env>()
+
+users.post('/',
+  zValidator('json', createUserSchema),
+  async (c) => {
+    const { email, name } = c.req.valid('json')
+    const db = c.env.DB
+
+    const result = await db
+      .prepare('INSERT INTO users (email, name) VALUES (?, ?)')
+      .bind(email, name)
+      .run()
+
+    return c.json({ id: result.meta.last_row_id, email, name }, 201)
+  }
+)
+```
+
+## Architecture Checklist
+
+Before completing:
+- [ ] All routes defined with HTTP methods
+- [ ] Env type includes all bindings
+- [ ] Zod schemas for all inputs
+- [ ] Middleware stack planned
+- [ ] Error handling strategy
+- [ ] RPC client type exported
+- [ ] Performance considerations noted
+- [ ] Security measures identified
+
+Now analyze the user's request and provide architectural guidance.