kiro-kit 0.1.0

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

@@ -0,0 +1,37 @@
+---
+name: web-frameworks
+description: Build companion web applications or admin panels with Next.js and React. Use when the mobile project needs a web dashboard, landing page, or backend admin interface.
+---
+
+# Web Frameworks
+
+Activate this skill when building web companions for mobile applications.
+
+## When to Use
+
+- Building admin dashboards for mobile app backends
+- Creating landing pages for app store marketing
+- Implementing web-based configuration panels
+- Building companion web apps that share logic with mobile
+- Setting up monorepo structures with shared packages
+
+## Next.js Patterns
+
+- App Router with Server Components by default
+- API routes for mobile app backends
+- Server-side rendering for SEO (landing pages)
+- Static generation for documentation sites
+
+## Shared Code Strategy
+
+- Extract business logic into shared packages
+- Use TypeScript for type safety across platforms
+- Share API client code between web and React Native
+- Maintain consistent data models across platforms
+
+## Rules
+
+- Web admin panels should be responsive but desktop-optimized
+- Landing pages must be mobile-first (users browse on phones)
+- Share validation logic between web and mobile
+- Keep web dependencies separate from mobile dependencies

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

@@ -0,0 +1,62 @@
+# Design: [Feature Name]
+
+## Overview
+
+High-level description of the technical approach for this feature.
+
+## Architecture
+
+### Layer Responsibilities
+
+- Presentation: widgets, screens, BLoC/state management
+- Domain: entities, use cases, repository interfaces
+- Data: API clients, local storage, DTOs, mappers
+
+### Data Flow
+
+```
+UI Event -> BLoC/Cubit -> Use Case -> Repository -> Data Source
+                                                        |
+UI State <- BLoC/Cubit <- Result  <- Repository  <------+
+```
+
+## Components
+
+### Screens
+- [Screen name]: purpose and key interactions
+
+### Widgets
+- [Widget name]: reusable component description
+
+### State Management
+- [BLoC/Provider name]: events, states, and transitions
+
+## Data Models
+
+```dart
+// Define key data models here
+```
+
+## Navigation
+
+- Route path and parameters
+- Deep link support
+- Transition animations
+
+## Platform Considerations
+
+- iOS-specific behavior or UI
+- Android-specific behavior or UI
+- Shared logic and components
+
+## Error Handling
+
+- Network errors: retry strategy
+- Validation errors: inline feedback
+- Unexpected errors: crash reporting
+
+## Testing Strategy
+
+- Widget tests for UI components
+- Unit tests for BLoC/business logic
+- Integration tests for critical flows

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

@@ -0,0 +1,47 @@
+# Requirements: [Feature Name]
+
+## Overview
+
+Brief description of the feature and its purpose within the mobile app.
+
+## User Stories
+
+- As a [user type], I want to [action] so that [benefit]
+
+## Functional Requirements
+
+### UI/UX
+- [ ] Screen renders correctly on phones and tablets
+- [ ] Loading states display appropriate indicators
+- [ ] Error states show actionable messages with retry option
+- [ ] Empty states provide guidance on next steps
+- [ ] Supports both portrait and landscape orientations
+
+### Behavior
+- [ ] [Describe interactive behavior]
+- [ ] [Describe data flow and state management]
+- [ ] [Describe offline behavior]
+
+### Platform-Specific
+- [ ] iOS: follows Human Interface Guidelines
+- [ ] Android: follows Material Design 3 guidelines
+- [ ] Handles platform-specific gestures correctly
+
+### Accessibility
+- [ ] Screen reader labels on all interactive elements
+- [ ] Touch targets minimum 44x44 points
+- [ ] Supports dynamic type / font scaling
+- [ ] Color is not sole indicator of state
+
+## Non-Functional Requirements
+
+- [ ] Screen loads under 500ms on mid-range devices
+- [ ] Smooth scrolling at 60fps
+- [ ] Works offline with cached data
+- [ ] Memory usage stable (no leaks)
+
+## Acceptance Criteria
+
+1. [Specific, testable criterion]
+2. [Specific, testable criterion]
+3. [Specific, testable criterion]

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

@@ -0,0 +1,52 @@
+# Tasks: [Feature Name]
+
+## Implementation Tasks
+
+- [ ] 1. Set up feature directory structure
+  - Create `lib/features/[name]/` with data, domain, presentation layers
+  - Create corresponding test directory
+
+- [ ] 2. Implement data layer
+  - Define data models and DTOs
+  - Implement repository
+  - Add local storage if offline support needed
+
+- [ ] 3. Implement domain layer
+  - Define entities
+  - Implement use cases
+  - Define repository interface
+
+- [ ] 4. Implement state management
+  - Create BLoC/Cubit with events and states
+  - Handle loading, success, and error states
+  - Write unit tests for state transitions
+
+- [ ] 5. Implement UI
+  - Build screen widget with proper layout
+  - Extract reusable sub-widgets
+  - Implement loading, error, and empty states
+  - Add accessibility labels and semantics
+
+- [ ] 6. Add navigation
+  - Register route in router configuration
+  - Implement deep link support if applicable
+  - Add transition animations
+
+- [ ] 7. Platform-specific work
+  - Verify iOS appearance and behavior
+  - Verify Android appearance and behavior
+  - Handle platform-specific edge cases
+
+- [ ] 8. Testing
+  - Write widget tests for screens
+  - Write unit tests for business logic
+  - Verify accessibility compliance
+  - Test on multiple screen sizes
+
+## Acceptance Verification
+
+- [ ] Feature works on iOS simulator
+- [ ] Feature works on Android emulator
+- [ ] All tests pass
+- [ ] No analyzer warnings
+- [ ] Accessibility audit passes

package/dist/presets/mobile/statusline.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// Statusline: outputs git branch + project name + time on one line.
+
+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 (e) {
+  // Not a git repo
+}
+
+const projectName = path.basename(process.cwd());
+const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+
+const parts = [];
+if (branch) parts.push(branch);
+parts.push(projectName);
+parts.push(time);
+
+process.stdout.write(parts.join(' | ') + '\n');

package/dist/presets/mobile/statusline.ps1

@@ -0,0 +1,16 @@
+# Statusline: outputs git branch + project name + time on one line.
+# Gracefully omits git branch if not a git repository.
+
+$Branch = ''
+try {
+    $Branch = (git rev-parse --abbrev-ref HEAD 2>$null)
+} catch {}
+
+$Project = Split-Path -Leaf (Get-Location)
+$Time = Get-Date -Format 'HH:mm'
+
+if ($Branch) {
+    Write-Output "$Branch | $Project | $Time"
+} else {
+    Write-Output "$Project | $Time"
+}

package/dist/presets/mobile/statusline.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Statusline: outputs git branch + project name + time on one line.
+# Gracefully omits git branch if not a git repository.
+
+BRANCH=""
+if git rev-parse --abbrev-ref HEAD >/dev/null 2>&1; then
+  BRANCH=$(git rev-parse --abbrev-ref HEAD)
+fi
+
+PROJECT=$(basename "$PWD")
+TIME=$(date +"%H:%M")
+
+if [ -n "$BRANCH" ]; then
+  echo "$BRANCH | $PROJECT | $TIME"
+else
+  echo "$PROJECT | $TIME"
+fi

package/dist/presets/mobile/steering/flutter-conventions.md

@@ -0,0 +1,60 @@
+---
+inclusion: always
+description: Flutter and Dart conventions for widget development, state management, and project structure.
+---
+
+# Flutter/Dart Conventions
+
+## Project Structure
+
+```
+lib/
+  app/                   App configuration, themes, routing
+  core/                  Shared utilities, constants, extensions
+  features/
+    [feature]/
+      data/              Repositories, data sources, models
+      domain/            Entities, use cases, interfaces
+      presentation/
+        screens/         Screen widgets
+        widgets/         Feature-specific widgets
+        bloc/            BLoC/Cubit classes
+  shared/
+    widgets/             Reusable widgets across features
+    services/            Shared services (auth, storage, network)
+test/
+  features/[feature]/    Mirror lib/ structure
+  helpers/               Test utilities and mocks
+```
+
+## Dart Rules
+
+- Sound null safety required (no `!` operator without justification)
+- Use `const` constructors wherever possible
+- Prefer `final` over `var` for local variables
+- Use named parameters for widgets with more than 2 parameters
+- Follow effective Dart style guide (snake_case files, PascalCase classes)
+
+## Widget Patterns
+
+- Prefer StatelessWidget; use StatefulWidget only when needed
+- Keep build methods under 80 lines; extract sub-widgets
+- Use `const` keyword on widget constructors and instances
+- Accept callbacks (VoidCallback, ValueChanged) for interactions
+- Use Key parameter for list items and animated widgets
+
+## State Management
+
+- BLoC for complex features with multiple events
+- Riverpod for dependency injection and simple state
+- Keep state immutable (use freezed or sealed classes)
+- Handle all async states: initial, loading, success, failure
+
+## Naming Conventions
+
+- Files: snake_case (`user_profile_screen.dart`)
+- Classes: PascalCase (`UserProfileScreen`)
+- Variables/functions: camelCase (`getUserProfile`)
+- Constants: camelCase or UPPER_SNAKE_CASE for top-level
+- BLoC events: PascalCase past tense (`UserProfileLoaded`)
+- BLoC states: PascalCase adjective (`UserProfileLoading`)

package/dist/presets/mobile/steering/mobile-patterns.md

@@ -0,0 +1,54 @@
+---
+inclusion: always
+description: Cross-platform mobile development patterns for navigation, data persistence, and platform adaptation.
+---
+
+# Mobile Development Patterns
+
+## Navigation
+
+- Use declarative routing (go_router for Flutter, React Navigation for RN)
+- Type-safe route parameters (no magic strings)
+- Support deep linking for all public screens
+- Implement authentication guards at router level
+- Handle back button consistently across platforms
+
+## Data Layer
+
+- Repository pattern: abstract data sources behind interfaces
+- Offline-first: local storage as source of truth, sync in background
+- Use DTOs for API responses, map to domain entities
+- Implement proper error types (network, validation, server)
+- Cache strategies: time-based expiry, manual invalidation
+
+## Error Handling
+
+- Typed error classes (not generic exceptions)
+- User-facing errors must be actionable
+- Network errors: retry with exponential backoff
+- Show appropriate UI for each error type
+- Log errors to crash reporting service
+
+## Platform Adaptation
+
+- Use platform-aware widgets (Material on Android, Cupertino on iOS)
+- Respect platform conventions (back gesture, navigation patterns)
+- Handle permissions with platform-appropriate UX
+- Support system themes (dark mode, dynamic color)
+- Adapt to screen sizes (phone, tablet, foldable)
+
+## Performance
+
+- Lazy load screens and heavy widgets
+- Use pagination for long lists
+- Cache images with proper memory management
+- Minimize main thread work (use isolates/workers)
+- Profile in release mode on real devices
+
+## Security
+
+- Store sensitive data in secure storage (Keychain/Keystore)
+- Certificate pinning for API communication
+- Obfuscate release builds
+- Never log sensitive user data
+- Validate all user input client-side and server-side

package/dist/presets/mobile/workflows/development-rules.md

@@ -0,0 +1,36 @@
+# Development Rules
+
+Follow these principles: YAGNI (You Aren't Gonna Need It), KISS (Keep It Simple, Stupid), DRY (Don't Repeat Yourself).
+
+## General
+
+- Use kebab-case for file names (Dart: snake_case per convention)
+- Keep individual code files under 200 lines
+- Split large widgets into smaller, focused sub-widgets
+- Use composition over inheritance
+- Extract business logic into separate service/repository classes
+- Separate UI from business logic (presentation vs domain layers)
+
+## Code Quality
+
+- Prioritize functionality and readability over strict style enforcement
+- Use try-catch error handling and cover security standards
+- No syntax errors -- code must compile at all times
+- Follow the codebase structure and code standards in `docs/`
+- Run `flutter analyze` or `eslint` before considering work complete
+
+## Pre-commit Rules
+
+- Run analyzer/linter before commit
+- Run tests before push
+- Keep commits focused on actual code changes
+- Do NOT commit confidential information (dotenv files, API keys, keystores)
+- Use conventional commit format
+
+## Implementation
+
+- Write clean, readable, maintainable code
+- Follow established architectural patterns
+- Handle edge cases and error scenarios
+- Do NOT create new enhanced files -- update existing files directly
+- Consider both platforms when making changes to shared code

package/dist/presets/mobile/workflows/documentation-management.md

@@ -0,0 +1,25 @@
+# Documentation Management
+
+## Automatic Updates Required
+
+- After feature implementation: update roadmap progress and changelog
+- After major milestones: review and adjust roadmap phases
+- After bug fixes: document fixes in changelog with severity and impact
+- After platform updates: record compatibility changes and migration steps
+
+## Documentation Triggers
+
+Update documentation when:
+- A development phase status changes
+- Major features are implemented or released
+- Significant bugs are resolved or security patches applied
+- Project timeline or scope adjustments are made
+- Platform SDK versions are updated
+- App store submissions or rejections occur
+
+## Update Protocol
+
+1. Before updates: read current roadmap and changelog status
+2. During updates: maintain version consistency and proper formatting
+3. After updates: verify links, dates, and cross-references
+4. Quality check: ensure updates align with actual implementation progress

package/dist/presets/mobile/workflows/orchestration-protocol.md

@@ -0,0 +1,19 @@
+# Orchestration Protocol
+
+## Sequential Chaining
+
+Chain agents when tasks have dependencies:
+- Planning then Implementation then Testing then Review: for feature development
+- Research then Design then Code then Documentation: for new screens
+- Each agent completes fully before the next begins
+- Pass context and outputs between agents in the chain
+
+## Parallel Execution
+
+Spawn multiple agents simultaneously for independent tasks:
+- iOS + Android platform-specific implementations
+- Widget + Tests + Docs: when implementing separate, non-conflicting components
+- Multiple Feature Branches: different agents working on isolated features
+- UI + State Management + Data Layer: parallel work on different layers
+- Ensure no file conflicts or shared resource contention
+- Plan integration points before parallel execution begins

package/dist/presets/mobile/workflows/primary-workflow.md

@@ -0,0 +1,36 @@
+# Primary Workflow
+
+Follow this cycle for all implementation work: Plan, Implement, Test, Review.
+
+## 1. Planning
+
+- Analyze requirements and break into concrete tasks
+- Research relevant packages and platform APIs before implementation
+- Create implementation plan with TODO items
+- Identify platform-specific considerations early
+
+## 2. Implementation
+
+- Write clean, readable, maintainable code
+- Follow established architectural patterns (BLoC, clean architecture)
+- Implement features according to specifications
+- Handle edge cases and error scenarios
+- After modifying code, run `flutter analyze` or typecheck to verify
+- Test on both platforms during development
+
+## 3. Testing
+
+- Write widget tests for UI components
+- Write unit tests for business logic
+- Ensure high code coverage on critical paths
+- Test error scenarios and edge cases
+- Validate on both iOS and Android
+- Do not use mocks or fake data just to pass tests
+
+## 4. Review
+
+- Review code for platform conventions compliance
+- Check for performance anti-patterns
+- Verify accessibility compliance
+- Ensure documentation is updated
+- Confirm no regressions on either platform

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "kiro-kit",
+  "version": "0.1.0",
+  "description": "CLI tool for bootstrapping engineer-grade Kiro IDE workspaces with curated presets.",
+  "type": "module",
+  "bin": {
+    "kiro-kit": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/ --ext .ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:structural": "vitest run --config vitest.structural.config.ts",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "kiro",
+    "ide",
+    "preset",
+    "cli",
+    "scaffolding",
+    "developer-tools",
+    "workspace"
+  ],
+  "author": "KK-Kiro-Kit Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ihatesea69/kiro-kit.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/ihatesea69/kiro-kit#readme",
+  "bugs": {
+    "url": "https://github.com/ihatesea69/kiro-kit/issues"
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "commander": "^12.1.0",
+    "diff": "^7.0.0",
+    "js-yaml": "^4.1.0",
+    "picocolors": "^1.1.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^6.0.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.14.0",
+    "fast-check": "^3.19.0",
+    "rimraf": "^6.0.0",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}