kiro-kit 0.1.0

package/dist/presets/fullstack/skills/repomix/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: repomix
+description: Package code repositories into single AI-friendly files for analysis. Use when you need to understand unfamiliar codebases or prepare context for AI tools.
+---
+
+# Repomix
+
+Activate when you need to package a codebase for AI analysis or understand an unfamiliar repository.
+
+## When to Use
+
+- Analyzing third-party libraries or repositories
+- Creating repository snapshots for LLM context
+- Preparing codebase for security audits
+- Understanding unfamiliar project structures
+- Generating documentation context
+
+## Usage
+
+```bash
+# Pack current directory
+repomix
+
+# Pack with specific includes
+repomix --include "src/**/*.ts"
+
+# Pack remote repository
+repomix --remote https://github.com/user/repo
+
+# Output formats
+repomix --style xml    # XML format (default)
+repomix --style markdown  # Markdown format
+```
+
+## Options
+
+- `--include` / `--exclude`: glob patterns for file filtering
+- `--remote`: pack a remote GitHub repository
+- `--style`: output format (xml, markdown, plain)
+- `--output`: custom output file path

package/dist/presets/fullstack/skills/research/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: research
+description: Research technologies, evaluate libraries, and gather technical information from documentation and authoritative sources.
+---
+
+# Research
+
+Activate when you need to investigate technologies, evaluate libraries, or gather technical information.
+
+## When to Use
+
+- Evaluating competing libraries or frameworks
+- Finding official documentation for a technology
+- Understanding best practices for a specific domain
+- Investigating new APIs or services
+- Comparing approaches with evidence
+
+## Process
+
+1. Define the research question clearly
+2. Identify authoritative sources (official docs, RFCs, reputable blogs)
+3. Cross-reference multiple sources for accuracy
+4. Evaluate applicability to the current project context
+5. Summarize findings with recommendations
+
+## Quality Standards
+
+- Prioritize official documentation over blog posts
+- Note version numbers and publication dates
+- Distinguish between stable and experimental features
+- Be explicit about what is unknown or uncertain
+- Provide actionable recommendations, not just information

package/dist/presets/fullstack/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: sequential-thinking
+description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision, and hypothesis verification.
+---
+
+# Sequential Thinking
+
+Activate for complex problems requiring step-by-step analysis with the ability to revise earlier conclusions.
+
+## When to Use
+
+- Complex problem decomposition
+- Adaptive planning that may need course correction
+- Analysis where initial assumptions may be wrong
+- Problems with unclear scope requiring exploration
+- Multi-step solutions with dependencies
+
+## Process
+
+1. Break the problem into numbered thought steps
+2. For each step, state what you know and what you are assuming
+3. After each step, evaluate whether previous steps need revision
+4. If a step reveals new information, revise earlier conclusions
+5. Continue until you reach a verified conclusion
+
+## Rules
+
+- Number each thought step explicitly
+- State assumptions clearly at each step
+- Mark revisions when earlier steps are updated
+- Do not skip steps to reach conclusions faster
+- Verify final conclusion against all steps

package/dist/presets/fullstack/skills/shopify/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: shopify
+description: Build Shopify applications, extensions, and themes using GraphQL/REST APIs, Shopify CLI, Polaris UI, and Liquid templating. Use when integrating with Shopify or building e-commerce features.
+---
+
+# Shopify
+
+Activate when building Shopify apps, extensions, themes, or integrating with Shopify APIs.
+
+## When to Use
+
+- Building Shopify apps with OAuth authentication
+- Creating checkout UI extensions
+- Developing themes with Liquid templating
+- Integrating Shopify Storefront API with Next.js
+- Managing products, orders, and customers via Admin API
+- Implementing webhooks for order/inventory events
+
+## Storefront API (Headless)
+
+- Use GraphQL Storefront API for custom storefronts
+- Implement cart with Cart API (createCart, addCartLines)
+- Handle checkout with Checkout API or Shopify Checkout
+- Cache product data with ISR or SWR
+
+## Admin API
+
+- Use GraphQL Admin API for store management
+- Authenticate with OAuth 2.0 (app installation flow)
+- Handle rate limits (cost-based throttling)
+- Use bulk operations for large data sets
+
+## Webhooks
+
+- Register webhooks for order, product, and inventory events
+- Verify webhook signatures (HMAC-SHA256)
+- Implement idempotent webhook handlers
+- Use webhook queues for reliable processing
+
+## Polaris UI
+
+- Use Polaris components for admin app interfaces
+- Follow Shopify design patterns for merchant UX
+- Use App Bridge for embedded app functionality

package/dist/presets/fullstack/skills/skill-creator/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: skill-creator
+description: Guide for creating effective agent skills. Use when users want to create or update skills that extend agent capabilities.
+---
+
+# Skill Creator
+
+Activate when creating or updating skills for the Kiro agent system.
+
+## Skill Structure
+
+```
+skills/<skill-name>/
+  SKILL.md              Required. Front-matter + instructions.
+  references/           Optional. Detailed docs.
+  scripts/              Optional. Automation scripts.
+  assets/               Optional. Static files.
+```
+
+## SKILL.md Requirements
+
+```yaml
+---
+name: skill-name        # kebab-case, required
+description: When to use # required
+---
+```
+
+## Best Practices
+
+- Keep SKILL.md concise (under 100 lines ideal)
+- Use progressive disclosure: overview in SKILL.md, details in references/
+- Write clear "When to Use" section for agent activation
+- Include practical examples and patterns
+- Avoid duplicating information available in official docs
+- Focus on decision-making guidance over reference material

package/dist/presets/fullstack/skills/template-skill/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: template-skill
+description: Template for creating new skills. Copy this directory and customize for your specific skill.
+---
+
+# Template Skill
+
+This is a template. Copy this directory to create a new skill.
+
+## When to Use
+
+- Describe the conditions that should trigger this skill activation
+
+## Capabilities
+
+- List what this skill enables the agent to do
+
+## Process
+
+1. Step-by-step workflow for using this skill
+2. Include decision points and branching logic
+3. Note any prerequisites or dependencies
+
+## References
+
+Place detailed documentation in the `references/` subdirectory for progressive disclosure.

package/dist/presets/fullstack/skills/ui-styling/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: ui-styling
+description: Style interfaces with Tailwind CSS, shadcn/ui components, and design tokens. Use when implementing visual designs, theming, or building accessible UI components.
+---
+
+# UI Styling
+
+Activate when styling components, implementing design systems, or working with Tailwind CSS and shadcn/ui.
+
+## When to Use
+
+- Styling components with Tailwind CSS utilities
+- Using shadcn/ui components (built on Radix UI)
+- Implementing dark mode and theming
+- Creating responsive layouts
+- Building accessible interactive components
+
+## Tailwind CSS
+
+- Use utility classes as primary styling method
+- Use `cn()` helper for conditional classes (clsx + tailwind-merge)
+- CSS variables for theme tokens in globals.css
+- Responsive: mobile-first with breakpoint prefixes (sm:, md:, lg:)
+- No inline styles except for dynamic values
+
+## shadcn/ui
+
+- Install components individually: `npx shadcn-ui@latest add button`
+- Customize via CSS variables in globals.css
+- Extend with Tailwind classes, not custom CSS
+- Components are copied into your project (not a dependency)
+
+## Accessibility
+
+- Color contrast 4.5:1 for normal text, 3:1 for large text
+- Focus-visible styles on all interactive elements
+- Touch targets minimum 44x44px on mobile
+- Respect prefers-reduced-motion
+- Use semantic HTML and ARIA attributes

package/dist/presets/fullstack/skills/web-frameworks/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: web-frameworks
+description: Build full-stack web applications with Next.js App Router, Server Components, and React patterns. Use when working with routing, rendering, or data fetching.
+---
+
+# Web Frameworks
+
+Activate when working with Next.js App Router, routing, rendering strategies, or full-stack React patterns.
+
+## When to Use
+
+- Setting up Next.js App Router routes and layouts
+- Implementing Server Components and Server Actions
+- Configuring rendering strategies (SSR, SSG, ISR, PPR)
+- Working with middleware and route handlers
+- Optimizing with streaming and Suspense
+
+## Next.js App Router
+
+- File-based routing in `app/` directory
+- `page.tsx` defines route segments
+- `layout.tsx` wraps child routes (persists across navigation)
+- `loading.tsx` provides Suspense fallback
+- `error.tsx` handles errors at segment level
+- Route groups `(name)` for organization without URL impact
+
+## Server Components (default)
+
+- No `use client` directive needed
+- Can fetch data directly (async components)
+- Cannot use hooks, event handlers, or browser APIs
+- Reduce client bundle size significantly
+
+## Server Actions
+
+- Define with `use server` directive
+- Use for form submissions and mutations
+- Integrate with `useActionState` for pending/error states
+- Revalidate cache with `revalidatePath` or `revalidateTag`

package/dist/presets/fullstack/specs/_templates/fullstack/design.md

@@ -0,0 +1,87 @@
+# Design: [Feature Name]
+
+## Architecture
+
+### System Context
+
+Describe how this feature fits into the Next.js application architecture.
+
+### Component Design
+
+```
+[Client Components] <-> [Server Components]
+  -> [Server Actions / API Routes]
+    -> [Service Layer]
+      -> [Repository / ORM]
+        -> [Database]
+```
+
+### Data Flow
+
+- Client interaction triggers Server Action or API call
+- Input validated with shared Zod schema
+- Service layer executes business logic
+- Repository persists data via ORM
+- Response flows back through layers
+- Client updates via revalidation or optimistic update
+
+## API Design
+
+### Endpoints / Server Actions
+
+| Method | Path / Action | Description |
+|--------|--------------|-------------|
+| GET | /api/v1/[resource] | List resources |
+| POST | /api/v1/[resource] | Create resource |
+| Server Action | create[Resource] | Form mutation |
+
+### Schemas (Shared Zod)
+
+```typescript
+const createSchema = z.object({
+  // Define shared validation
+});
+```
+
+## Database Design
+
+### Schema Changes
+
+```prisma
+model Resource {
+  id        String   @id @default(cuid())
+  // fields
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+## Frontend Design
+
+### Component Tree
+
+```
+Page (Server Component)
+  -> DataFetcher (Server Component, async)
+    -> ClientInteraction (Client Component)
+      -> Form (React Hook Form + Zod)
+```
+
+### State Management
+
+- Server state: fetched in Server Components
+- Form state: React Hook Form
+- Optimistic updates: useOptimistic hook
+
+## Testing Strategy
+
+- Unit: service layer logic, Zod schemas, utility functions
+- Integration: API routes with test database
+- Component: React Testing Library for interactive components
+- E2E: critical user flows with Playwright
+
+## Security Considerations
+
+- Input validation approach (shared Zod schemas)
+- Authentication mechanism (middleware + session check)
+- Authorization model (resource ownership)

package/dist/presets/fullstack/specs/_templates/fullstack/requirements.md

@@ -0,0 +1,54 @@
+# Requirements: [Feature Name]
+
+## Overview
+
+Brief description of the feature spanning frontend and backend.
+
+## User Stories
+
+- As a [user type], I want to [action] so that [benefit]
+
+## Functional Requirements
+
+### UI/UX
+- [ ] Component renders correctly across breakpoints
+- [ ] Loading states display skeleton UI during data fetch
+- [ ] Error states show actionable messages with retry option
+- [ ] Empty states provide guidance on next steps
+
+### API Layer
+- [ ] Endpoint accepts valid payloads and returns correct responses
+- [ ] Input validation rejects malformed requests with descriptive errors
+- [ ] Authentication and authorization enforced on protected endpoints
+- [ ] Pagination implemented for list endpoints
+
+### Data Layer
+- [ ] Database schema supports the required data model
+- [ ] Migrations are reversible and tested
+- [ ] Indexes cover primary query patterns
+- [ ] Data integrity constraints enforced at database level
+
+### Business Logic
+- [ ] [Describe core business rules]
+- [ ] [Describe state transitions]
+- [ ] [Describe integration requirements]
+
+## Non-Functional Requirements
+
+- [ ] First Contentful Paint under 1.5s
+- [ ] API response time under 200ms for CRUD operations
+- [ ] Database queries execute under 50ms (p95)
+- [ ] Bundle size increase under 50KB (gzipped)
+
+## Security Requirements
+
+- [ ] Input validated on both client and server (Zod)
+- [ ] Authentication required for non-public endpoints
+- [ ] Authorization checked at resource level
+- [ ] No sensitive data exposed in client bundle
+
+## Acceptance Criteria
+
+1. [Specific, testable criterion]
+2. [Specific, testable criterion]
+3. [Specific, testable criterion]

package/dist/presets/fullstack/specs/_templates/fullstack/tasks.md

@@ -0,0 +1,40 @@
+# Tasks: [Feature Name]
+
+## Phase 1: Data Layer
+
+- [ ] 1.1 Design database schema and create migration
+- [ ] 1.2 Implement repository/data access layer
+- [ ] 1.3 Add database indexes for query patterns
+- [ ] 1.4 Write repository unit tests
+
+## Phase 2: Business Logic and API
+
+- [ ] 2.1 Implement service layer with core business rules
+- [ ] 2.2 Add shared Zod validation schemas
+- [ ] 2.3 Implement API route handlers or Server Actions
+- [ ] 2.4 Add authentication/authorization checks
+- [ ] 2.5 Write API integration tests
+
+## Phase 3: Frontend Components
+
+- [ ] 3.1 Create Server Components for data display
+- [ ] 3.2 Create Client Components for interactivity
+- [ ] 3.3 Implement form with validation (React Hook Form + Zod)
+- [ ] 3.4 Add loading, error, and empty states
+- [ ] 3.5 Implement responsive design
+- [ ] 3.6 Write component tests
+
+## Phase 4: Integration and Polish
+
+- [ ] 4.1 Connect frontend to API layer
+- [ ] 4.2 Implement optimistic updates where appropriate
+- [ ] 4.3 Add error boundaries at route segments
+- [ ] 4.4 Verify accessibility (keyboard nav, screen reader)
+- [ ] 4.5 Run E2E tests for critical flows
+
+## Phase 5: Security and Performance
+
+- [ ] 5.1 Security audit (auth, validation, injection)
+- [ ] 5.2 Performance optimization (bundle size, query speed)
+- [ ] 5.3 Add caching where appropriate (ISR, Redis)
+- [ ] 5.4 Update documentation

package/dist/presets/fullstack/statusline.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const path = require('path');
+
+let branch = '';
+try {
+  branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+} catch (_) {
+  branch = 'no-git';
+}
+
+const projectName = path.basename(process.cwd());
+const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit' });
+
+process.stdout.write(`${branch} | ${projectName} | ${time}`);

package/dist/presets/fullstack/statusline.ps1

@@ -0,0 +1,5 @@
+$branch = try { git rev-parse --abbrev-ref HEAD 2>$null } catch { "no-git" }
+if (-not $branch) { $branch = "no-git" }
+$project = Split-Path -Leaf (Get-Location)
+$time = Get-Date -Format "HH:mm"
+Write-Host "$branch | $project | $time" -NoNewline

package/dist/presets/fullstack/statusline.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "no-git")
+project=$(basename "$PWD")
+time=$(date +%H:%M)
+printf "%s | %s | %s" "$branch" "$project" "$time"

package/dist/presets/fullstack/steering/fullstack-conventions.md

@@ -0,0 +1,77 @@
+---
+inclusion: always
+description: Fullstack conventions for Next.js/T3 stack covering both frontend components and backend API routes, data layer, and shared types.
+---
+
+# Fullstack Conventions
+
+## Project Structure
+
+```
+src/
+  app/                 Next.js App Router (pages, layouts, API routes)
+  components/
+    ui/                shadcn/ui primitives
+    [feature]/         Feature-specific components
+  server/
+    api/               tRPC routers or REST handlers
+    db/                Database schema and queries
+    services/          Business logic layer
+    auth/              Authentication configuration
+  hooks/               Custom React hooks
+  lib/                 Shared utilities (client + server)
+  types/               Shared TypeScript definitions
+  env.ts               Environment variable validation
+prisma/                Prisma schema and migrations (if using Prisma)
+drizzle/               Drizzle schema and migrations (if using Drizzle)
+```
+
+## TypeScript Rules
+
+- Strict mode enabled, no `any` types
+- Use `interface` for component props, `type` for unions/intersections
+- Share types between client and server via `src/types/`
+- Validate environment variables at build time with `@t3-oss/env-nextjs`
+- Use Zod schemas for runtime validation on both client and server
+
+## Frontend Conventions
+
+- Server Components by default (no directive needed)
+- Add `'use client'` only when using hooks, events, or browser APIs
+- Keep Client Components as leaf nodes
+- Use Suspense boundaries for async data loading
+- Style with Tailwind CSS utility classes
+- Use `cn()` helper for conditional classes
+
+## Backend Conventions
+
+- Layered architecture: handler -> service -> repository
+- Validate all input at the handler layer (Zod)
+- Return consistent error response format
+- Use parameterized queries for all database operations
+- Implement proper HTTP status codes
+- Keep route handlers thin -- delegate to service layer
+
+## Data Layer
+
+- Define schema in a single source of truth (Prisma/Drizzle)
+- Use migrations for all schema changes (never manual DDL)
+- Create indexes based on query patterns
+- Use transactions for multi-table operations
+- Soft delete where audit trail is needed
+
+## Authentication
+
+- Use middleware for route protection
+- Server-only secrets (no NEXT_PUBLIC_ for sensitive data)
+- Session validation on every protected API route
+- RBAC checks at the service layer
+
+## Naming Conventions
+
+- Components: PascalCase (`UserProfile.tsx`)
+- API routes: kebab-case (`/api/user-settings`)
+- Database tables: snake_case (`user_profiles`)
+- TypeScript types: PascalCase (`UserProfile`)
+- Environment variables: UPPER_SNAKE_CASE (`DATABASE_URL`)
+- Files: kebab-case for non-component files (`api-client.ts`)

package/dist/presets/fullstack/steering/nextjs-app-router.md

@@ -0,0 +1,92 @@
+---
+inclusion: always
+description: Next.js App Router patterns for routing, data fetching, caching, Server Actions, and API route handlers.
+---
+
+# Next.js App Router
+
+## Route Structure
+
+```
+app/
+  layout.tsx           Root layout (html, body, providers)
+  page.tsx             Home page
+  loading.tsx          Root loading state
+  error.tsx            Root error boundary
+  not-found.tsx        404 page
+  (auth)/              Route group for auth pages
+    login/page.tsx
+    register/page.tsx
+  (dashboard)/         Route group for authenticated pages
+    layout.tsx         Dashboard layout (sidebar, nav)
+    page.tsx           Dashboard home
+    settings/page.tsx
+  api/                 Route handlers (REST endpoints)
+    [resource]/route.ts
+    trpc/[trpc]/route.ts  tRPC handler (if using tRPC)
+```
+
+## Data Fetching
+
+- Server Components: fetch directly or call server functions
+- Use `cache: 'force-cache'` for static data (default)
+- Use `cache: 'no-store'` for dynamic data
+- Use `next: { revalidate: 60 }` for ISR
+- Parallel fetching: `Promise.all` for independent requests
+- Use Server Actions for mutations (form submissions)
+
+## Server Actions
+
+- Define with `'use server'` directive
+- Use for form submissions and data mutations
+- Integrate with `useActionState` for pending/error states
+- Revalidate cache with `revalidatePath` or `revalidateTag`
+- Always validate input with Zod before processing
+
+## Route Handlers (API Routes)
+
+```typescript
+// app/api/users/route.ts
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  // Validate auth, fetch data, return response
+  return NextResponse.json(data);
+}
+
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  // Validate, process, return
+  return NextResponse.json(result, { status: 201 });
+}
+```
+
+## Middleware
+
+- Use `middleware.ts` at project root for auth checks
+- Match routes with `config.matcher` array
+- Redirect unauthenticated users to login
+- Set headers for API routes (CORS, rate limiting)
+
+## Performance
+
+- Use `next/image` for all images
+- Use `next/font` for font loading
+- Dynamic imports for heavy components: `dynamic(() => import(...))`
+- Implement streaming with nested Suspense boundaries
+- Use Route Segment Config for per-route caching
+
+## Environment Variables
+
+- `NEXT_PUBLIC_*` for client-side variables
+- Server-only variables: no prefix (never exposed to client)
+- Validate with `@t3-oss/env-nextjs` at build time
+- Use `.env.local` for local development
+
+## Error Handling
+
+- `error.tsx` at each route segment for granular boundaries
+- `error.tsx` must be a Client Component (`'use client'`)
+- Use `notFound()` for 404 responses
+- Log errors to monitoring service in production
+- Return structured error responses from API routes